# -*- coding: utf-8 -*-
from gi.repository import GObject
BINARY_AGE = r"""22811"""


class CoordType:
    """Specifies how xy coordinates are to be interpreted. Used by functions such
as atk_component_get_position() and atk_text_get_character_extents()"""
    SCREEN = 0
    WINDOW = 1


class HyperlinkStateFlags:
    """Describes the type of link"""
    INLINE = 1
INTERFACE_AGE = r"""1"""


class KeyEventType:
    """Specifies the type of a keyboard evemt."""
    PRESS = 0
    RELEASE = 1
    LAST_DEFINED = 2


class Layer:
    """Describes the layer of a component

These enumerated "layer values" are used when determining which UI
rendering layer a component is drawn into, which can help in making
determinations of when components occlude one another."""
    INVALID = 0
    BACKGROUND = 1
    CANVAS = 2
    WIDGET = 3
    MDI = 4
    POPUP = 5
    OVERLAY = 6
    WINDOW = 7
MAJOR_VERSION = r"""2"""
MICRO_VERSION = r"""1"""
MINOR_VERSION = r"""28"""


class RelationType:
    """Describes the type of the relation"""
    NULL = 0
    CONTROLLED_BY = 1
    CONTROLLER_FOR = 2
    LABEL_FOR = 3
    LABELLED_BY = 4
    MEMBER_OF = 5
    NODE_CHILD_OF = 6
    FLOWS_TO = 7
    FLOWS_FROM = 8
    SUBWINDOW_OF = 9
    EMBEDS = 10
    EMBEDDED_BY = 11
    POPUP_FOR = 12
    PARENT_WINDOW_OF = 13
    DESCRIBED_BY = 14
    DESCRIPTION_FOR = 15
    NODE_PARENT_OF = 16
    DETAILS = 17
    DETAILS_FOR = 18
    ERROR_MESSAGE = 19
    ERROR_FOR = 20
    LAST_DEFINED = 21


class Role:
    """Describes the role of an object

These are the built-in enumerated roles that UI components can have in
ATK.  Other roles may be added at runtime, so an AtkRole >=
ATK_ROLE_LAST_DEFINED is not necessarily an error."""
    INVALID = 0
    ACCELERATOR_LABEL = 1
    ALERT = 2
    ANIMATION = 3
    ARROW = 4
    CALENDAR = 5
    CANVAS = 6
    CHECK_BOX = 7
    CHECK_MENU_ITEM = 8
    COLOR_CHOOSER = 9
    COLUMN_HEADER = 10
    COMBO_BOX = 11
    DATE_EDITOR = 12
    DESKTOP_ICON = 13
    DESKTOP_FRAME = 14
    DIAL = 15
    DIALOG = 16
    DIRECTORY_PANE = 17
    DRAWING_AREA = 18
    FILE_CHOOSER = 19
    FILLER = 20
    FONT_CHOOSER = 21
    FRAME = 22
    GLASS_PANE = 23
    HTML_CONTAINER = 24
    ICON = 25
    IMAGE = 26
    INTERNAL_FRAME = 27
    LABEL = 28
    LAYERED_PANE = 29
    LIST = 30
    LIST_ITEM = 31
    MENU = 32
    MENU_BAR = 33
    MENU_ITEM = 34
    OPTION_PANE = 35
    PAGE_TAB = 36
    PAGE_TAB_LIST = 37
    PANEL = 38
    PASSWORD_TEXT = 39
    POPUP_MENU = 40
    PROGRESS_BAR = 41
    PUSH_BUTTON = 42
    RADIO_BUTTON = 43
    RADIO_MENU_ITEM = 44
    ROOT_PANE = 45
    ROW_HEADER = 46
    SCROLL_BAR = 47
    SCROLL_PANE = 48
    SEPARATOR = 49
    SLIDER = 50
    SPLIT_PANE = 51
    SPIN_BUTTON = 52
    STATUSBAR = 53
    TABLE = 54
    TABLE_CELL = 55
    TABLE_COLUMN_HEADER = 56
    TABLE_ROW_HEADER = 57
    TEAR_OFF_MENU_ITEM = 58
    TERMINAL = 59
    TEXT = 60
    TOGGLE_BUTTON = 61
    TOOL_BAR = 62
    TOOL_TIP = 63
    TREE = 64
    TREE_TABLE = 65
    UNKNOWN = 66
    VIEWPORT = 67
    WINDOW = 68
    HEADER = 69
    FOOTER = 70
    PARAGRAPH = 71
    RULER = 72
    APPLICATION = 73
    AUTOCOMPLETE = 74
    EDIT_BAR = 75
    EMBEDDED = 76
    ENTRY = 77
    CHART = 78
    CAPTION = 79
    DOCUMENT_FRAME = 80
    HEADING = 81
    PAGE = 82
    SECTION = 83
    REDUNDANT_OBJECT = 84
    FORM = 85
    LINK = 86
    INPUT_METHOD_WINDOW = 87
    TABLE_ROW = 88
    TREE_ITEM = 89
    DOCUMENT_SPREADSHEET = 90
    DOCUMENT_PRESENTATION = 91
    DOCUMENT_TEXT = 92
    DOCUMENT_WEB = 93
    DOCUMENT_EMAIL = 94
    COMMENT = 95
    LIST_BOX = 96
    GROUPING = 97
    IMAGE_MAP = 98
    NOTIFICATION = 99
    INFO_BAR = 100
    LEVEL_BAR = 101
    TITLE_BAR = 102
    BLOCK_QUOTE = 103
    AUDIO = 104
    VIDEO = 105
    DEFINITION = 106
    ARTICLE = 107
    LANDMARK = 108
    LOG = 109
    MARQUEE = 110
    MATH = 111
    RATING = 112
    TIMER = 113
    DESCRIPTION_LIST = 114
    DESCRIPTION_TERM = 115
    DESCRIPTION_VALUE = 116
    STATIC = 117
    MATH_FRACTION = 118
    MATH_ROOT = 119
    SUBSCRIPT = 120
    SUPERSCRIPT = 121
    FOOTNOTE = 122
    LAST_DEFINED = 123


class StateType:
    """The possible types of states of an object"""
    INVALID = 0
    ACTIVE = 1
    ARMED = 2
    BUSY = 3
    CHECKED = 4
    DEFUNCT = 5
    EDITABLE = 6
    ENABLED = 7
    EXPANDABLE = 8
    EXPANDED = 9
    FOCUSABLE = 10
    FOCUSED = 11
    HORIZONTAL = 12
    ICONIFIED = 13
    MODAL = 14
    MULTI_LINE = 15
    MULTISELECTABLE = 16
    OPAQUE = 17
    PRESSED = 18
    RESIZABLE = 19
    SELECTABLE = 20
    SELECTED = 21
    SENSITIVE = 22
    SHOWING = 23
    SINGLE_LINE = 24
    STALE = 25
    TRANSIENT = 26
    VERTICAL = 27
    VISIBLE = 28
    MANAGES_DESCENDANTS = 29
    INDETERMINATE = 30
    TRUNCATED = 31
    REQUIRED = 32
    INVALID_ENTRY = 33
    SUPPORTS_AUTOCOMPLETION = 34
    SELECTABLE_TEXT = 35
    DEFAULT = 36
    ANIMATED = 37
    VISITED = 38
    CHECKABLE = 39
    HAS_POPUP = 40
    HAS_TOOLTIP = 41
    READ_ONLY = 42
    LAST_DEFINED = 43


class TextAttribute:
    """Describes the text attributes supported"""
    INVALID = 0
    LEFT_MARGIN = 1
    RIGHT_MARGIN = 2
    INDENT = 3
    INVISIBLE = 4
    EDITABLE = 5
    PIXELS_ABOVE_LINES = 6
    PIXELS_BELOW_LINES = 7
    PIXELS_INSIDE_WRAP = 8
    BG_FULL_HEIGHT = 9
    RISE = 10
    UNDERLINE = 11
    STRIKETHROUGH = 12
    SIZE = 13
    SCALE = 14
    WEIGHT = 15
    LANGUAGE = 16
    FAMILY_NAME = 17
    BG_COLOR = 18
    FG_COLOR = 19
    BG_STIPPLE = 20
    FG_STIPPLE = 21
    WRAP_MODE = 22
    DIRECTION = 23
    JUSTIFICATION = 24
    STRETCH = 25
    VARIANT = 26
    STYLE = 27
    LAST_DEFINED = 28


class TextBoundary:
    """Text boundary types used for specifying boundaries for regions of text.
This enumeration is deprecated since 2.9.4 and should not be used. Use
AtkTextGranularity with #atk_text_get_string_at_offset instead."""
    CHAR = 0
    WORD_START = 1
    WORD_END = 2
    SENTENCE_START = 3
    SENTENCE_END = 4
    LINE_START = 5
    LINE_END = 6


class TextClipType:
    """Describes the type of clipping required."""
    NONE = 0
    MIN = 1
    MAX = 2
    BOTH = 3


class TextGranularity:
    """Text granularity types used for specifying the granularity of the region of
text we are interested in."""
    CHAR = 0
    WORD = 1
    SENTENCE = 2
    LINE = 3
    PARAGRAPH = 4
VERSION_MIN_REQUIRED = r"""2"""


class ValueType:
    """Default types for a given value. Those are defined in order to
easily get localized strings to describe a given value or a given
subrange, using atk_value_type_get_localized_name()."""
    VERY_WEAK = 0
    WEAK = 1
    ACCEPTABLE = 2
    STRONG = 3
    VERY_STRONG = 4
    VERY_LOW = 5
    LOW = 6
    MEDIUM = 7
    HIGH = 8
    VERY_HIGH = 9
    VERY_BAD = 10
    BAD = 11
    GOOD = 12
    VERY_GOOD = 13
    BEST = 14
    LAST_DEFINED = 15

def add_focus_tracker(focus_tracker=None):
    """    Adds the specified function to the list of functions to be called
    when an object receives focus.
    @param focus_tracker: Function to be added to the list of functions to be called when an object receives focus.
    @type focus_tracker: EventListener
    @returns: added focus tracker id, or 0 on failure.
    @rtype: int
    """
    return object

def add_global_event_listener(listener=None, event_type=None):
    """    Adds the specified function to the list of functions to be called
    when an ATK event of type event_type occurs.
    
    The format of event_type is the following:
     "ATK:&lt;atk_type&gt;:&lt;atk_event&gt;:&lt;atk_event_detail&gt;
    
    Where "ATK" works as the namespace, &lt;atk_interface&gt; is the name of
    the ATK type (interface or object), &lt;atk_event&gt; is the name of the
    signal defined on that interface and &lt;atk_event_detail&gt; is the
    gsignal detail of that signal. You can find more info about gsignal
    details here:
    http://developer.gnome.org/gobject/stable/gobject-Signals.html
    
    The first three parameters are mandatory. The last one is optional.
    
    For example:
      ATK:AtkObject:state-change
      ATK:AtkText:text-selection-changed
      ATK:AtkText:text-insert:system
    
    Toolkit implementor note: ATK provides a default implementation for
    this virtual method. ATK implementors are discouraged from
    reimplementing this method.
    
    Toolkit implementor note: this method is not intended to be used by
    ATK implementors but by ATK consumers.
    
    ATK consumers note: as this method adds a listener for a given ATK
    type, that type should be already registered on the GType system
    before calling this method. A simple way to do that is creating an
    instance of #AtkNoOpObject. This class implements all ATK
    interfaces, so creating the instance will register all ATK types as
    a collateral effect.
    @param listener: the listener to notify
    @param event_type: the type of event for which notification is requested
    @type listener: GObject.SignalEmissionHook
    @type event_type: str
    @returns: added event listener id, or 0 on failure.
    @rtype: int
    """
    return object

def add_key_event_listener(listener=None, data=None):
    """    Adds the specified function to the list of functions to be called
           when a key event occurs.  The @data element will be passed to the
           #AtkKeySnoopFunc (@listener) as the @func_data param, on notification.
    @param listener: the listener to notify
    @param data: a #gpointer that points to a block of data that should be sent to the registered listeners,        along with the event notification, when it occurs.
    @type listener: KeySnoopFunc
    @type data: gpointer
    @returns: added event listener id, or 0 on failure.
    @rtype: int
    """
    return object

def attribute_set_free(attrib_set=None):
    """    Frees the memory used by an #AtkAttributeSet, including all its
    #AtkAttributes.
    @param attrib_set: The #AtkAttributeSet to free
    @type attrib_set: AttributeSet
    @returns: 
    @rtype: None
    """
    return object

def focus_tracker_init(init=None):
    """    Specifies the function to be called for focus tracker initialization.
    This function should be called by an implementation of the
    ATK interface if any specific work needs to be done to enable
    focus tracking.
    @param init: Function to be called for focus tracker initialization
    @type init: EventListenerInit
    @returns: 
    @rtype: None
    """
    return object

def focus_tracker_notify(object=None):
    """    Cause the focus tracker functions which have been specified to be
    executed for the object.
    @param object: an #AtkObject
    @type object: Object
    @returns: 
    @rtype: None
    """
    return object

def get_binary_age():
    """    Returns the binary age as passed to libtool when building the ATK
    library the process is running against.
    @returns: the binary age of the ATK library
    @rtype: int
    """
    return object

def get_default_registry():
    """    Gets a default implementation of the #AtkObjectFactory/type
    registry.
    Note: For most toolkit maintainers, this will be the correct
    registry for registering new #AtkObject factories. Following
    a call to this function, maintainers may call atk_registry_set_factory_type()
    to associate an #AtkObjectFactory subclass with the GType of objects
    for whom accessibility information will be provided.
    @returns: a default implementation of the #AtkObjectFactory/type registry
    @rtype: Registry
    """
    return object

def get_focus_object():
    """    Gets the currently focused object.
    @returns: the currently focused object for the current application
    @rtype: Object
    """
    return object

def get_interface_age():
    """    Returns the interface age as passed to libtool when building the
    ATK library the process is running against.
    @returns: the interface age of the ATK library
    @rtype: int
    """
    return object

def get_major_version():
    """    Returns the major version number of the ATK library.  (e.g. in ATK
    version 2.7.4 this is 2.)
    
    This function is in the library, so it represents the ATK library
    your code is running against. In contrast, the #ATK_MAJOR_VERSION
    macro represents the major version of the ATK headers you have
    included when compiling your code.
    @returns: the major version number of the ATK library
    @rtype: int
    """
    return object

def get_micro_version():
    """    Returns the micro version number of the ATK library.  (e.g. in ATK
    version 2.7.4 this is 4.)
    
    This function is in the library, so it represents the ATK library
    your code is are running against. In contrast, the
    #ATK_MICRO_VERSION macro represents the micro version of the ATK
    headers you have included when compiling your code.
    @returns: the micro version number of the ATK library
    @rtype: int
    """
    return object

def get_minor_version():
    """    Returns the minor version number of the ATK library.  (e.g. in ATK
    version 2.7.4 this is 7.)
    
    This function is in the library, so it represents the ATK library
    your code is are running against. In contrast, the
    #ATK_MINOR_VERSION macro represents the minor version of the ATK
    headers you have included when compiling your code.
    @returns: the minor version number of the ATK library
    @rtype: int
    """
    return object

def get_root():
    """    Gets the root accessible container for the current application.
    @returns: the root accessible container for the current application
    @rtype: Object
    """
    return object

def get_toolkit_name():
    """    Gets name string for the GUI toolkit implementing ATK for this application.
    @returns: name string for the GUI toolkit implementing ATK for this application
    @rtype: str
    """
    return object

def get_toolkit_version():
    """    Gets version string for the GUI toolkit implementing ATK for this application.
    @returns: version string for the GUI toolkit implementing ATK for this application
    @rtype: str
    """
    return object

def get_version():
    """    Gets the current version for ATK.
    @returns: version string for ATK
    @rtype: str
    """
    return object

def relation_type_for_name(name=None):
    """    Get the #AtkRelationType type corresponding to a relation name.
    @param name: a string which is the (non-localized) name of an ATK relation type.
    @type name: str
    @returns: the #AtkRelationType enumerated type corresponding to the specified name,
          or #ATK_RELATION_NULL if no matching relation type is found.
    @rtype: RelationType
    """
    return object

def relation_type_get_name(type=None):
    """    Gets the description string describing the #AtkRelationType @type.
    @param type: The #AtkRelationType whose name is required
    @type type: RelationType
    @returns: the string describing the AtkRelationType
    @rtype: str
    """
    return object

def relation_type_register(name=None):
    """    Associate @name with a new #AtkRelationType
    @param name: a name string
    @type name: str
    @returns: an #AtkRelationType associated with @name
    @rtype: RelationType
    """
    return object

def remove_focus_tracker(tracker_id=None):
    """    
    @param tracker_id: the id of the focus tracker to remove
    @type tracker_id: int
    @returns: 
    @rtype: None
    """
    return object

def remove_global_event_listener(listener_id=None):
    """    @listener_id is the value returned by #atk_add_global_event_listener
    when you registered that event listener.
    
    Toolkit implementor note: ATK provides a default implementation for
    this virtual method. ATK implementors are discouraged from
    reimplementing this method.
    
    Toolkit implementor note: this method is not intended to be used by
    ATK implementors but by ATK consumers.
    
    Removes the specified event listener
    @param listener_id: the id of the event listener to remove
    @type listener_id: int
    @returns: 
    @rtype: None
    """
    return object

def remove_key_event_listener(listener_id=None):
    """    @listener_id is the value returned by #atk_add_key_event_listener
    when you registered that event listener.
    
    Removes the specified event listener.
    @param listener_id: the id of the event listener to remove
    @type listener_id: int
    @returns: 
    @rtype: None
    """
    return object

def role_for_name(name=None):
    """    Get the #AtkRole type corresponding to a rolew name.
    @param name: a string which is the (non-localized) name of an ATK role.
    @type name: str
    @returns: the #AtkRole enumerated type corresponding to the specified name,
          or #ATK_ROLE_INVALID if no matching role is found.
    @rtype: Role
    """
    return object

def role_get_localized_name(role=None):
    """    Gets the localized description string describing the #AtkRole @role.
    @param role: The #AtkRole whose localized name is required
    @type role: Role
    @returns: the localized string describing the AtkRole
    @rtype: str
    """
    return object

def role_get_name(role=None):
    """    Gets the description string describing the #AtkRole @role.
    @param role: The #AtkRole whose name is required
    @type role: Role
    @returns: the string describing the AtkRole
    @rtype: str
    """
    return object

def role_register(name=None):
    """    Registers the role specified by @name. @name must be a meaningful
    name. So it should not be empty, or consisting on whitespaces.
    @param name: a character string describing the new role.
    @type name: str
    @returns: an #AtkRole for the new role if added properly. ATK_ROLE_INVALID in case of error.
    @rtype: Role
    """
    return object

def state_type_for_name(name=None):
    """    Gets the #AtkStateType corresponding to the description string @name.
    @param name: a character string state name
    @type name: str
    @returns: an #AtkStateType corresponding to @name
    @rtype: StateType
    """
    return object

def state_type_get_name(type=None):
    """    Gets the description string describing the #AtkStateType @type.
    @param type: The #AtkStateType whose name is required
    @type type: StateType
    @returns: the string describing the AtkStateType
    @rtype: str
    """
    return object

def state_type_register(name=None):
    """    Register a new object state.
    @param name: a character string describing the new state.
    @type name: str
    @returns: an #AtkState value for the new state.
    @rtype: StateType
    """
    return object

def text_attribute_for_name(name=None):
    """    Get the #AtkTextAttribute type corresponding to a text attribute name.
    @param name: a string which is the (non-localized) name of an ATK text attribute.
    @type name: str
    @returns: the #AtkTextAttribute enumerated type corresponding to the specified name,
          or #ATK_TEXT_ATTRIBUTE_INVALID if no matching text attribute is found.
    @rtype: TextAttribute
    """
    return object

def text_attribute_get_name(attr=None):
    """    Gets the name corresponding to the #AtkTextAttribute
    @param attr: The #AtkTextAttribute whose name is required
    @type attr: TextAttribute
    @returns: a string containing the name; this string should not be freed
    @rtype: str
    """
    return object

def text_attribute_get_value(attr=None, index_=None):
    """    Gets the value for the index of the #AtkTextAttribute
    @param attr: The #AtkTextAttribute for which a value is required
    @param index_: The index of the required value
    @type attr: TextAttribute
    @type index_: int
    @returns: a string containing the value; this string should not be freed; %NULL is returned if there are no values maintained for the attr value.
    @rtype: str
    """
    return object

def text_attribute_register(name=None):
    """    Associate @name with a new #AtkTextAttribute
    @param name: a name string
    @type name: str
    @returns: an #AtkTextAttribute associated with @name
    @rtype: TextAttribute
    """
    return object

def text_free_ranges(ranges=None):
    """    Frees the memory associated with an array of AtkTextRange. It is assumed
    that the array was returned by the function atk_text_get_bounded_ranges
    and is NULL terminated.
    @param ranges: A pointer to an array of #AtkTextRange which is   to be freed.
    @returns: 
    @rtype: None
    """
    return object

def value_type_get_localized_name(value_type=None):
    """    Gets the localized description string describing the #AtkValueType @value_type.
    @param value_type: The #AtkValueType whose localized name is required
    @type value_type: ValueType
    @returns: the localized string describing the #AtkValueType
    @rtype: str
    """
    return object

def value_type_get_name(value_type=None):
    """    Gets the description string describing the #AtkValueType @value_type.
    @param value_type: The #AtkValueType whose name is required
    @type value_type: ValueType
    @returns: the string describing the #AtkValueType
    @rtype: str
    """
    return object


class Action():
    """#AtkAction should be implemented by instances of #AtkObject classes
with which the user can interact directly, i.e. buttons,
checkboxes, scrollbars, e.g. components which are not "passive"
providers of UI information.

Exceptions: when the user interaction is already covered by another
appropriate interface such as #AtkEditableText (insert/delete text,
etc.) or #AtkValue (set value) then these actions should not be
exposed by #AtkAction as well.

Though most UI interactions on components should be invocable via
keyboard as well as mouse, there will generally be a close mapping
between "mouse actions" that are possible on a component and the
AtkActions.  Where mouse and keyboard actions are redundant in
effect, #AtkAction should expose only one action rather than
exposing redundant actions if possible.  By convention we have been
using "mouse centric" terminology for #AtkAction names."""
    
    def do_action(self, i=None):
        """        Perform the specified action on the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def get_description(self, i=None):
        """        Returns a description of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a description string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_keybinding(self, i=None):
        """        Gets the keybinding which can be used to activate this action, if one
        exists. The string returned should contain localized, human-readable,
        key sequences as they would appear when displayed on screen. It must
        be in the format "mnemonic;sequence;shortcut".
        
        - The mnemonic key activates the object if it is presently enabled onscreen.
          This typically corresponds to the underlined letter within the widget.
          Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
          a button.
        - The sequence is the full list of keys which invoke the action even if the
          relevant element is not currently shown on screen. For instance, for a menu
          item the sequence is the keybindings used to open the parent menus before
          invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
          traditional "New..." menu item.
        - The shortcut, if it exists, will invoke the same action without showing
          the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
          traditional "New..." menu item.
        
        Example: For a traditional "New..." menu item, the expected return value
        would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
        for the German locale. If, hypothetically, this menu item lacked a mnemonic,
        it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
        @rtype: str
        """
        return object
    
    def get_localized_name(self, i=None):
        """        Returns the localized name of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a name string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_n_actions(self):
        """        Gets the number of accessible actions available on the object.
        If there are more than one, the first one is considered the
        "default" action of the object.
        @returns: a the number of actions, or 0 if @action does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_name(self, i=None):
        """        Returns a non-localized string naming the specified action of the
        object. This name is generally not descriptive of the end result
        of the action, but instead names the 'interaction type' which the
        object supports. By convention, the above strings should be used to
        represent the actions which correspond to the common point-and-click
        interaction techniques of the same name: i.e.
        "click", "press", "release", "drag", "drop", "popup", etc.
        The "popup" action should be used to pop up a context menu for the
        object, if one exists.
        
        For technical reasons, some toolkits cannot guarantee that the
        reported action is actually 'bound' to a nontrivial user event;
        i.e. the result of some actions via atk_action_do_action() may be
        NIL.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a name string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def set_description(self, i=None, desc=None):
        """        Sets a description of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @param desc: the description to be assigned to this action
        @type i: int
        @type desc: str
        @returns: a gboolean representing if the description was successfully set;
        @rtype: bool
        """
        return object
    
    def do_action(self, i=None):
        """        Perform the specified action on the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def get_description(self, i=None):
        """        Returns a description of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a description string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_keybinding(self, i=None):
        """        Gets the keybinding which can be used to activate this action, if one
        exists. The string returned should contain localized, human-readable,
        key sequences as they would appear when displayed on screen. It must
        be in the format "mnemonic;sequence;shortcut".
        
        - The mnemonic key activates the object if it is presently enabled onscreen.
          This typically corresponds to the underlined letter within the widget.
          Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
          a button.
        - The sequence is the full list of keys which invoke the action even if the
          relevant element is not currently shown on screen. For instance, for a menu
          item the sequence is the keybindings used to open the parent menus before
          invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
          traditional "New..." menu item.
        - The shortcut, if it exists, will invoke the same action without showing
          the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
          traditional "New..." menu item.
        
        Example: For a traditional "New..." menu item, the expected return value
        would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
        for the German locale. If, hypothetically, this menu item lacked a mnemonic,
        it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
        @rtype: str
        """
        return object
    
    def get_localized_name(self, i=None):
        """        Returns the localized name of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a name string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_n_actions(self):
        """        Gets the number of accessible actions available on the object.
        If there are more than one, the first one is considered the
        "default" action of the object.
        @returns: a the number of actions, or 0 if @action does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_name(self, i=None):
        """        Returns a non-localized string naming the specified action of the
        object. This name is generally not descriptive of the end result
        of the action, but instead names the 'interaction type' which the
        object supports. By convention, the above strings should be used to
        represent the actions which correspond to the common point-and-click
        interaction techniques of the same name: i.e.
        "click", "press", "release", "drag", "drop", "popup", etc.
        The "popup" action should be used to pop up a context menu for the
        object, if one exists.
        
        For technical reasons, some toolkits cannot guarantee that the
        reported action is actually 'bound' to a nontrivial user event;
        i.e. the result of some actions via atk_action_do_action() may be
        NIL.
        @param i: the action index corresponding to the action to be performed
        @type i: int
        @returns: a name string, or %NULL if @action does not implement this interface.
        @rtype: str
        """
        return object
    
    def set_description(self, i=None, desc=None):
        """        Sets a description of the specified action of the object.
        @param i: the action index corresponding to the action to be performed
        @param desc: the description to be assigned to this action
        @type i: int
        @type desc: str
        @returns: a gboolean representing if the description was successfully set;
        @rtype: bool
        """
        return object


class ActionIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def do_action(self):
        return object

    @property
    def get_n_actions(self):
        return object

    @property
    def get_description(self):
        return object

    @property
    def get_name(self):
        return object

    @property
    def get_keybinding(self):
        return object

    @property
    def set_description(self):
        return object

    @property
    def get_localized_name(self):
        return object


class Attribute():
    """AtkAttribute is a string name/value pair representing a generic
attribute. This can be used to expose additional information from
an accessible object as a whole (see atk_object_get_attributes())
or an document (see atk_document_get_attributes()). In the case of
text attributes (see atk_text_get_default_attributes()),
#AtkTextAttribute enum defines all the possible text attribute
names. You can use atk_text_attribute_get_name() to get the string
name from the enum value. See also atk_text_attribute_for_name()
and atk_text_attribute_get_value() for more information.

A string name/value pair representing a generic attribute."""
    @staticmethod
    def set_free(attrib_set=None):
        """        Frees the memory used by an #AtkAttributeSet, including all its
        #AtkAttributes.
        @param attrib_set: The #AtkAttributeSet to free
        @type attrib_set: AttributeSet
        @returns: 
        @rtype: None
        """
        return object

    @property
    def name(self):
        return object

    @property
    def value(self):
        return object


class Component():
    """#AtkComponent should be implemented by most if not all UI elements
with an actual on-screen presence, i.e. components which can be
said to have a screen-coordinate bounding box.  Virtually all
widgets will need to have #AtkComponent implementations provided
for their corresponding #AtkObject class.  In short, only UI
elements which are *not* GUI elements will omit this ATK interface.

A possible exception might be textual information with a
transparent background, in which case text glyph bounding box
information is provided by #AtkText."""
    
    def add_focus_handler(self, handler=None):
        """        Add the specified handler to the set of functions to be called
        when this object receives focus events (in or out). If the handler is
        already added it is not added again
        @param handler: The #AtkFocusHandler to be attached to @component
        @type handler: FocusHandler
        @returns: a handler id which can be used in atk_component_remove_focus_handler() or zero if the handler was already added.
        @rtype: int
        """
        return object
    
    def bounds_changed(self, bounds=None):
        """        
        @type bounds: Rectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def contains(self, x=None, y=None, coord_type=None):
        """        Checks whether the specified point is within the extent of the @component.
        
        Toolkit implementor note: ATK provides a default implementation for
        this virtual method. In general there are little reason to
        re-implement it.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
        @rtype: bool
        """
        return object
    
    def get_alpha(self):
        """        Returns the alpha value (i.e. the opacity) for this
        @component, on a scale from 0 (fully transparent) to 1.0
        (fully opaque).
        @returns: An alpha value from 0 to 1.0, inclusive.
        @rtype: float
        """
        return object
    
    def get_extents(self, x=None, y=None, width=None, height=None, coord_type=None):
        """        Gets the rectangle which gives the extent of the @component.
        @param x: address of #gint to put x coordinate
        @param y: address of #gint to put y coordinate
        @param width: address of #gint to put width
        @param height: address of #gint to put height
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_layer(self):
        """        Gets the layer of the component.
        @returns: an #AtkLayer which is the layer of the component
        @rtype: Layer
        """
        return object
    
    def get_mdi_zorder(self):
        """        Gets the zorder of the component. The value G_MININT will be returned
        if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
        @returns: a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
        @rtype: int
        """
        return object
    
    def get_position(self, x=None, y=None, coord_type=None):
        """        Gets the position of @component in the form of
        a point specifying @component's top-left corner.
        @param x: address of #gint to put x coordinate position
        @param y: address of #gint to put y coordinate position
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_size(self, width=None, height=None):
        """        Gets the size of the @component in terms of width and height.
        @param width: address of #gint to put width of @component
        @param height: address of #gint to put height of @component
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def grab_focus(self):
        """        Grabs focus for this @component.
        @returns: %TRUE if successful, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def ref_accessible_at_point(self, x=None, y=None, coord_type=None):
        """        Gets a reference to the accessible child, if one exists, at the
        coordinate point specified by @x and @y.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: a reference to the accessible child, if one exists
        @rtype: Object
        """
        return object
    
    def remove_focus_handler(self, handler_id=None):
        """        Remove the handler specified by @handler_id from the list of
        functions to be executed when this object receives focus events
        (in or out).
        @param handler_id: the handler id of the focus handler to be removed from @component
        @type handler_id: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_extents(self, x=None, y=None, width=None, height=None, coord_type=None):
        """        Sets the extents of @component.
        @param x: x coordinate
        @param y: y coordinate
        @param width: width to set for @component
        @param height: height to set for @component
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE whether the extents were set or not
        @rtype: bool
        """
        return object
    
    def set_position(self, x=None, y=None, coord_type=None):
        """        Sets the postition of @component.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE whether or not the position was set or not
        @rtype: bool
        """
        return object
    
    def set_size(self, width=None, height=None):
        """        Set the size of the @component in terms of width and height.
        @param width: width to set for @component
        @param height: height to set for @component
        @type width: int
        @type height: int
        @returns: %TRUE or %FALSE whether the size was set or not
        @rtype: bool
        """
        return object
    
    def add_focus_handler(self, handler=None):
        """        Add the specified handler to the set of functions to be called
        when this object receives focus events (in or out). If the handler is
        already added it is not added again
        @param handler: The #AtkFocusHandler to be attached to @component
        @type handler: FocusHandler
        @returns: a handler id which can be used in atk_component_remove_focus_handler() or zero if the handler was already added.
        @rtype: int
        """
        return object
    
    def contains(self, x=None, y=None, coord_type=None):
        """        Checks whether the specified point is within the extent of the @component.
        
        Toolkit implementor note: ATK provides a default implementation for
        this virtual method. In general there are little reason to
        re-implement it.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
        @rtype: bool
        """
        return object
    
    def get_alpha(self):
        """        Returns the alpha value (i.e. the opacity) for this
        @component, on a scale from 0 (fully transparent) to 1.0
        (fully opaque).
        @returns: An alpha value from 0 to 1.0, inclusive.
        @rtype: float
        """
        return object
    
    def get_extents(self, x=None, y=None, width=None, height=None, coord_type=None):
        """        Gets the rectangle which gives the extent of the @component.
        @param x: address of #gint to put x coordinate
        @param y: address of #gint to put y coordinate
        @param width: address of #gint to put width
        @param height: address of #gint to put height
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_layer(self):
        """        Gets the layer of the component.
        @returns: an #AtkLayer which is the layer of the component
        @rtype: Layer
        """
        return object
    
    def get_mdi_zorder(self):
        """        Gets the zorder of the component. The value G_MININT will be returned
        if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
        @returns: a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
        @rtype: int
        """
        return object
    
    def get_position(self, x=None, y=None, coord_type=None):
        """        Gets the position of @component in the form of
        a point specifying @component's top-left corner.
        @param x: address of #gint to put x coordinate position
        @param y: address of #gint to put y coordinate position
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_size(self, width=None, height=None):
        """        Gets the size of the @component in terms of width and height.
        @param width: address of #gint to put width of @component
        @param height: address of #gint to put height of @component
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def grab_focus(self):
        """        Grabs focus for this @component.
        @returns: %TRUE if successful, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def ref_accessible_at_point(self, x=None, y=None, coord_type=None):
        """        Gets a reference to the accessible child, if one exists, at the
        coordinate point specified by @x and @y.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: a reference to the accessible child, if one exists
        @rtype: Object
        """
        return object
    
    def remove_focus_handler(self, handler_id=None):
        """        Remove the handler specified by @handler_id from the list of
        functions to be executed when this object receives focus events
        (in or out).
        @param handler_id: the handler id of the focus handler to be removed from @component
        @type handler_id: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_extents(self, x=None, y=None, width=None, height=None, coord_type=None):
        """        Sets the extents of @component.
        @param x: x coordinate
        @param y: y coordinate
        @param width: width to set for @component
        @param height: height to set for @component
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE whether the extents were set or not
        @rtype: bool
        """
        return object
    
    def set_position(self, x=None, y=None, coord_type=None):
        """        Sets the postition of @component.
        @param x: x coordinate
        @param y: y coordinate
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: %TRUE or %FALSE whether or not the position was set or not
        @rtype: bool
        """
        return object
    
    def set_size(self, width=None, height=None):
        """        Set the size of the @component in terms of width and height.
        @param width: width to set for @component
        @param height: height to set for @component
        @type width: int
        @type height: int
        @returns: %TRUE or %FALSE whether the size was set or not
        @rtype: bool
        """
        return object


class ComponentIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def add_focus_handler(self):
        return object

    @property
    def contains(self):
        return object

    @property
    def ref_accessible_at_point(self):
        return object

    @property
    def get_extents(self):
        return object

    @property
    def get_position(self):
        return object

    @property
    def get_size(self):
        return object

    @property
    def grab_focus(self):
        return object

    @property
    def remove_focus_handler(self):
        return object

    @property
    def set_extents(self):
        return object

    @property
    def set_position(self):
        return object

    @property
    def set_size(self):
        return object

    @property
    def get_layer(self):
        return object

    @property
    def get_mdi_zorder(self):
        return object

    @property
    def bounds_changed(self):
        return object

    @property
    def get_alpha(self):
        return object


class Document():
    """The AtkDocument interface should be supported by any object whose
content is a representation or view of a document.  The AtkDocument
interface should appear on the toplevel container for the document
content; however AtkDocument instances may be nested (i.e. an
AtkDocument may be a descendant of another AtkDocument) in those
cases where one document contains "embedded content" which can
reasonably be considered a document in its own right."""
    
    def get_current_page_number(self):
        """        
        @returns: current page number inside @document. -1 if not implemented, not know by the implementor or irrelevant.
        @rtype: int
        """
        return object
    
    def get_document(self):
        """        Gets a %gpointer that points to an instance of the DOM.  It is
        up to the caller to check atk_document_get_type to determine
        how to cast this pointer.
        @returns: a %gpointer that points to an instance of the DOM.
        @rtype: gpointer
        """
        return object
    
    def get_document_attribute_value(self, attribute_name=None):
        """        
        @type attribute_name: str
        @returns: 
        @rtype: str
        """
        return object
    
    def get_document_attributes(self):
        """        
        @returns: 
        @rtype: AttributeSet
        """
        return object
    
    def get_document_locale(self):
        """        
        @returns: 
        @rtype: str
        """
        return object
    
    def get_document_type(self):
        """        Gets a string indicating the document type.
        @returns: a string indicating the document type
        @rtype: str
        """
        return object
    
    def get_page_count(self):
        """        
        @returns: total page count of @document. -1 if not implemented, not know by the implementor or irrelevant.
        @rtype: int
        """
        return object
    
    def set_document_attribute(self, attribute_name=None, attribute_value=None):
        """        
        @type attribute_name: str
        @type attribute_value: str
        @returns: 
        @rtype: bool
        """
        return object
    
    def get_attribute_value(self, attribute_name=None):
        """        
        @param attribute_name: a character string representing the name of the attribute            whose value is being queried.
        @type attribute_name: str
        @returns: a string value associated with the named
    attribute for this document, or NULL if a value for
    #attribute_name has not been specified for this document.
        @rtype: str
        """
        return object
    
    def get_attributes(self):
        """        Gets an AtkAttributeSet which describes document-wide
                 attributes as name-value pairs.
        @returns: An AtkAttributeSet containing the explicitly
          set name-value-pair attributes associated with this document
          as a whole.
        @rtype: AttributeSet
        """
        return object
    
    def get_current_page_number(self):
        """        
        @returns: current page number inside @document. -1 if not implemented, not know by the implementor or irrelevant.
        @rtype: int
        """
        return object
    
    def get_document(self):
        """        Gets a %gpointer that points to an instance of the DOM.  It is
        up to the caller to check atk_document_get_type to determine
        how to cast this pointer.
        @returns: a %gpointer that points to an instance of the DOM.
        @rtype: gpointer
        """
        return object
    
    def get_document_type(self):
        """        Gets a string indicating the document type.
        @returns: a string indicating the document type
        @rtype: str
        """
        return object
    
    def get_locale(self):
        """        Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
                 of the content of this document instance.  Individual
                 text substrings or images within this document may have
                 a different locale, see atk_text_get_attributes and
                 atk_image_get_image_locale.
        @returns: a UTF-8 string indicating the POSIX-style LC_MESSAGES
          locale of the document content as a whole, or NULL if
          the document content does not specify a locale.
        @rtype: str
        """
        return object
    
    def get_page_count(self):
        """        
        @returns: total page count of @document. -1 if not implemented, not know by the implementor or irrelevant.
        @rtype: int
        """
        return object
    
    def set_attribute_value(self, attribute_name=None, attribute_value=None):
        """        
        @param attribute_name: a character string representing the name of the attribute            whose value is being set.
        @param attribute_value: a string value to be associated with #attribute_name.
        @type attribute_name: str
        @type attribute_value: str
        @returns: TRUE if #value is successfully associated with #attribute_name
          for this document, FALSE otherwise (e.g. if the document does not
          allow the attribute to be modified).
        @rtype: bool
        """
        return object


class DocumentIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_document_type(self):
        return object

    @property
    def get_document(self):
        return object

    @property
    def get_document_locale(self):
        return object

    @property
    def get_document_attributes(self):
        return object

    @property
    def get_document_attribute_value(self):
        return object

    @property
    def set_document_attribute(self):
        return object

    @property
    def get_current_page_number(self):
        return object

    @property
    def get_page_count(self):
        return object


class EditableText():
    """#AtkEditableText should be implemented by UI components which
contain text which the user can edit, via the #AtkObject
corresponding to that component (see #AtkObject).

#AtkEditableText is a subclass of #AtkText, and as such, an object
which implements #AtkEditableText is by definition an #AtkText
implementor as well.

See also: #AtkText"""
    
    def copy_text(self, start_pos=None, end_pos=None):
        """        Copy text from @start_pos up to, but not including @end_pos
        to the clipboard.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def cut_text(self, start_pos=None, end_pos=None):
        """        Copy text from @start_pos up to, but not including @end_pos
        to the clipboard and then delete from the widget.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def delete_text(self, start_pos=None, end_pos=None):
        """        Delete text @start_pos up to, but not including @end_pos.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def insert_text(self, string=None, length=None, position=None):
        """        Insert text at a given position.
        @param string: the text to insert
        @param length: the length of text to insert, in bytes
        @param position: The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
        @type string: str
        @type length: int
        @type position: int
        @returns: 
        @rtype: None
        """
        return object
    
    def paste_text(self, position=None):
        """        Paste text from clipboard to specified @position.
        @param position: position to paste
        @type position: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_run_attributes(self, attrib_set=None, start_offset=None, end_offset=None):
        """        Sets the attributes for a specified range. See the ATK_ATTRIBUTE
        macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
        that can be set. Note that other attributes that do not have corresponding
        ATK_ATTRIBUTE macros may also be set for certain text widgets.
        @param attrib_set: an #AtkAttributeSet
        @param start_offset: start of range in which to set attributes
        @param end_offset: end of range in which to set attributes
        @type attrib_set: AttributeSet
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if attributes successfully set for the specified range, otherwise %FALSE
        @rtype: bool
        """
        return object
    
    def set_text_contents(self, string=None):
        """        Set text contents of @text.
        @param string: string to set for text contents of @text
        @type string: str
        @returns: 
        @rtype: None
        """
        return object
    
    def copy_text(self, start_pos=None, end_pos=None):
        """        Copy text from @start_pos up to, but not including @end_pos
        to the clipboard.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def cut_text(self, start_pos=None, end_pos=None):
        """        Copy text from @start_pos up to, but not including @end_pos
        to the clipboard and then delete from the widget.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def delete_text(self, start_pos=None, end_pos=None):
        """        Delete text @start_pos up to, but not including @end_pos.
        @param start_pos: start position
        @param end_pos: end position
        @type start_pos: int
        @type end_pos: int
        @returns: 
        @rtype: None
        """
        return object
    
    def insert_text(self, string=None, length=None, position=None):
        """        Insert text at a given position.
        @param string: the text to insert
        @param length: the length of text to insert, in bytes
        @param position: The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
        @type string: str
        @type length: int
        @type position: int
        @returns: 
        @rtype: None
        """
        return object
    
    def paste_text(self, position=None):
        """        Paste text from clipboard to specified @position.
        @param position: position to paste
        @type position: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_run_attributes(self, attrib_set=None, start_offset=None, end_offset=None):
        """        Sets the attributes for a specified range. See the ATK_ATTRIBUTE
        macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
        that can be set. Note that other attributes that do not have corresponding
        ATK_ATTRIBUTE macros may also be set for certain text widgets.
        @param attrib_set: an #AtkAttributeSet
        @param start_offset: start of range in which to set attributes
        @param end_offset: end of range in which to set attributes
        @type attrib_set: AttributeSet
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if attributes successfully set for the specified range, otherwise %FALSE
        @rtype: bool
        """
        return object
    
    def set_text_contents(self, string=None):
        """        Set text contents of @text.
        @param string: string to set for text contents of @text
        @type string: str
        @returns: 
        @rtype: None
        """
        return object


class EditableTextIface():
    """"""

    @property
    def parent_interface(self):
        return object

    @property
    def set_run_attributes(self):
        return object

    @property
    def set_text_contents(self):
        return object

    @property
    def insert_text(self):
        return object

    @property
    def copy_text(self):
        return object

    @property
    def cut_text(self):
        return object

    @property
    def delete_text(self):
        return object

    @property
    def paste_text(self):
        return object


class GObjectAccessibleClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def pad1(self):
        return object

    @property
    def pad2(self):
        return object


class Hyperlink(GObject.Object, Action):
    """An ATK object which encapsulates a link or set of links (for
instance in the case of client-side image maps) in a hypertext
document.  It may implement the AtkAction interface.  AtkHyperlink
may also be used to refer to inline embedded content, since it
allows specification of a start and end offset within the host
AtkHypertext object."""
    
    def get_end_index(self):
        """        Gets the index with the hypertext document at which this link ends.
        @returns: the index with the hypertext document at which this link ends
        @rtype: int
        """
        return object
    
    def get_n_anchors(self):
        """        Gets the number of anchors associated with this hyperlink.
        @returns: the number of anchors associated with this hyperlink
        @rtype: int
        """
        return object
    
    def get_object(self, i=None):
        """        Returns the item associated with this hyperlinks nth anchor.
        For instance, the returned #AtkObject will implement #AtkText
        if @link_ is a text hyperlink, #AtkImage if @link_ is an image
        hyperlink etc.
        
        Multiple anchors are primarily used by client-side image maps.
        @param i: a (zero-index) integer specifying the desired anchor
        @type i: int
        @returns: an #AtkObject associated with this hyperlinks i-th anchor
        @rtype: Object
        """
        return object
    
    def get_start_index(self):
        """        Gets the index with the hypertext document at which this link begins.
        @returns: the index with the hypertext document at which this link begins
        @rtype: int
        """
        return object
    
    def get_uri(self, i=None):
        """        Get a the URI associated with the anchor specified
        by @i of @link_.
        
        Multiple anchors are primarily used by client-side image maps.
        @param i: a (zero-index) integer specifying the desired anchor
        @type i: int
        @returns: a string specifying the URI
        @rtype: str
        """
        return object
    
    def is_selected_link(self):
        """        Determines whether this AtkHyperlink is selected
        @returns: True if the AtkHyperlink is selected, False otherwise
        @rtype: bool
        """
        return object
    
    def is_valid(self):
        """        Since the document that a link is associated with may have changed
        this method returns %TRUE if the link is still valid (with
        respect to the document it references) and %FALSE otherwise.
        @returns: whether or not this link is still valid
        @rtype: bool
        """
        return object
    
    def link_activated(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def link_state(self):
        """        
        @returns: 
        @rtype: int
        """
        return object
    
    def get_end_index(self):
        """        Gets the index with the hypertext document at which this link ends.
        @returns: the index with the hypertext document at which this link ends
        @rtype: int
        """
        return object
    
    def get_n_anchors(self):
        """        Gets the number of anchors associated with this hyperlink.
        @returns: the number of anchors associated with this hyperlink
        @rtype: int
        """
        return object
    
    def get_object(self, i=None):
        """        Returns the item associated with this hyperlinks nth anchor.
        For instance, the returned #AtkObject will implement #AtkText
        if @link_ is a text hyperlink, #AtkImage if @link_ is an image
        hyperlink etc.
        
        Multiple anchors are primarily used by client-side image maps.
        @param i: a (zero-index) integer specifying the desired anchor
        @type i: int
        @returns: an #AtkObject associated with this hyperlinks i-th anchor
        @rtype: Object
        """
        return object
    
    def get_start_index(self):
        """        Gets the index with the hypertext document at which this link begins.
        @returns: the index with the hypertext document at which this link begins
        @rtype: int
        """
        return object
    
    def get_uri(self, i=None):
        """        Get a the URI associated with the anchor specified
        by @i of @link_.
        
        Multiple anchors are primarily used by client-side image maps.
        @param i: a (zero-index) integer specifying the desired anchor
        @type i: int
        @returns: a string specifying the URI
        @rtype: str
        """
        return object
    
    def is_inline(self):
        """        Indicates whether the link currently displays some or all of its
                  content inline.  Ordinary HTML links will usually return
                  %FALSE, but an inline &lt;src&gt; HTML element will return
                  %TRUE.
        @returns: whether or not this link displays its content inline.
        @rtype: bool
        """
        return object
    
    def is_selected_link(self):
        """        Determines whether this AtkHyperlink is selected
        @returns: True if the AtkHyperlink is selected, False otherwise
        @rtype: bool
        """
        return object
    
    def is_valid(self):
        """        Since the document that a link is associated with may have changed
        this method returns %TRUE if the link is still valid (with
        respect to the document it references) and %FALSE otherwise.
        @returns: whether or not this link is still valid
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object


class HyperlinkClass():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_uri(self):
        return object

    @property
    def get_object(self):
        return object

    @property
    def get_end_index(self):
        return object

    @property
    def get_start_index(self):
        return object

    @property
    def is_valid(self):
        return object

    @property
    def get_n_anchors(self):
        return object

    @property
    def link_state(self):
        return object

    @property
    def is_selected_link(self):
        return object

    @property
    def link_activated(self):
        return object

    @property
    def pad1(self):
        return object


class HyperlinkImpl():
    """AtkHyperlinkImpl allows AtkObjects to refer to their associated
AtkHyperlink instance, if one exists.  AtkHyperlinkImpl differs
from AtkHyperlink in that AtkHyperlinkImpl is an interface, whereas
AtkHyperlink is a object type.  The AtkHyperlinkImpl interface
allows a client to query an AtkObject for the availability of an
associated AtkHyperlink instance, and obtain that instance.  It is
thus particularly useful in cases where embedded content or inline
content within a text object is present, since the embedding text
object implements AtkHypertext and the inline/embedded objects are
exposed as children which implement AtkHyperlinkImpl, in addition
to their being obtainable via AtkHypertext:getLink followed by
AtkHyperlink:getObject.

The AtkHyperlinkImpl interface should be supported by objects
exposed within the hierarchy as children of an AtkHypertext
container which correspond to "links" or embedded content within
the text.  HTML anchors are not, for instance, normally exposed
this way, but embedded images and components which appear inline in
the content of a text object are. The AtkHyperlinkIface interface
allows a means of determining which children are hyperlinks in this
sense of the word, and for obtaining their corresponding
AtkHyperlink object, from which the embedding range, URI, etc. can
be obtained.

To some extent this interface exists because, for historical
reasons, AtkHyperlink was defined as an object type, not an
interface.  Thus, in order to interact with AtkObjects via
AtkHyperlink semantics, a new interface was required."""
    
    def get_hyperlink(self):
        """        Gets the hyperlink associated with this object.
        @returns: an AtkHyperlink object which points to this implementing AtkObject.
        @rtype: Hyperlink
        """
        return object
    
    def get_hyperlink(self):
        """        Gets the hyperlink associated with this object.
        @returns: an AtkHyperlink object which points to this implementing AtkObject.
        @rtype: Hyperlink
        """
        return object


class HyperlinkImplIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_hyperlink(self):
        return object


class Hypertext():
    """An interface used for objects which implement linking between
multiple resource or content locations, or multiple 'markers'
within a single document.  A Hypertext instance is associated with
one or more Hyperlinks, which are associated with particular
offsets within the Hypertext's included content.  While this
interface is derived from Text, there is no requirement that
Hypertext instances have textual content; they may implement Image
as well, and Hyperlinks need not have non-zero text offsets."""
    
    def get_link(self, link_index=None):
        """        Gets the link in this hypertext document at index
        @link_index
        @param link_index: an integer specifying the desired link
        @type link_index: int
        @returns: the link in this hypertext document at index @link_index
        @rtype: Hyperlink
        """
        return object
    
    def get_link_index(self, char_index=None):
        """        Gets the index into the array of hyperlinks that is associated with
        the character specified by @char_index.
        @param char_index: a character index
        @type char_index: int
        @returns: an index into the array of hyperlinks in @hypertext, or -1 if there is no hyperlink associated with this character.
        @rtype: int
        """
        return object
    
    def get_n_links(self):
        """        Gets the number of links within this hypertext document.
        @returns: the number of links within this hypertext document
        @rtype: int
        """
        return object
    
    def link_selected(self, link_index=None):
        """        
        @type link_index: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_link(self, link_index=None):
        """        Gets the link in this hypertext document at index
        @link_index
        @param link_index: an integer specifying the desired link
        @type link_index: int
        @returns: the link in this hypertext document at index @link_index
        @rtype: Hyperlink
        """
        return object
    
    def get_link_index(self, char_index=None):
        """        Gets the index into the array of hyperlinks that is associated with
        the character specified by @char_index.
        @param char_index: a character index
        @type char_index: int
        @returns: an index into the array of hyperlinks in @hypertext, or -1 if there is no hyperlink associated with this character.
        @rtype: int
        """
        return object
    
    def get_n_links(self):
        """        Gets the number of links within this hypertext document.
        @returns: the number of links within this hypertext document
        @rtype: int
        """
        return object


class HypertextIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_link(self):
        return object

    @property
    def get_n_links(self):
        return object

    @property
    def get_link_index(self):
        return object

    @property
    def link_selected(self):
        return object


class Image():
    """#AtkImage should be implemented by #AtkObject subtypes on behalf of
components which display image/pixmap information onscreen, and
which provide information (other than just widget borders, etc.)
via that image content.  For instance, icons, buttons with icons,
toolbar elements, and image viewing panes typically should
implement #AtkImage.

#AtkImage primarily provides two types of information: coordinate
information (useful for screen review mode of screenreaders, and
for use by onscreen magnifiers), and descriptive information.  The
descriptive information is provided for alternative, text-only
presentation of the most significant information present in the
image."""
    
    def get_image_description(self):
        """        Get a textual description of this image.
        @returns: a string representing the image description
        @rtype: str
        """
        return object
    
    def get_image_locale(self):
        """        
        @returns: a string corresponding to the POSIX LC_MESSAGES locale used by the image description, or %NULL if the image does not specify a locale.
        @rtype: str
        """
        return object
    
    def get_image_position(self, x=None, y=None, coord_type=None):
        """        Gets the position of the image in the form of a point specifying the
        images top-left corner.
        @param x: address of #gint to put x coordinate position; otherwise, -1 if value cannot be obtained.
        @param y: address of #gint to put y coordinate position; otherwise, -1 if value cannot be obtained.
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_image_size(self, width=None, height=None):
        """        Get the width and height in pixels for the specified image.
        The values of @width and @height are returned as -1 if the
        values cannot be obtained (for instance, if the object is not onscreen).
        @param width: filled with the image width, or -1 if the value cannot be obtained.
        @param height: filled with the image height, or -1 if the value cannot be obtained.
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_image_description(self, description=None):
        """        Sets the textual description for this image.
        @param description: a string description to set for @image
        @type description: str
        @returns: boolean TRUE, or FALSE if operation could not be completed.
        @rtype: bool
        """
        return object
    
    def get_image_description(self):
        """        Get a textual description of this image.
        @returns: a string representing the image description
        @rtype: str
        """
        return object
    
    def get_image_locale(self):
        """        
        @returns: a string corresponding to the POSIX LC_MESSAGES locale used by the image description, or %NULL if the image does not specify a locale.
        @rtype: str
        """
        return object
    
    def get_image_position(self, x=None, y=None, coord_type=None):
        """        Gets the position of the image in the form of a point specifying the
        images top-left corner.
        @param x: address of #gint to put x coordinate position; otherwise, -1 if value cannot be obtained.
        @param y: address of #gint to put y coordinate position; otherwise, -1 if value cannot be obtained.
        @param coord_type: specifies whether the coordinates are relative to the screen or to the components top level window
        @type x: int
        @type y: int
        @type coord_type: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_image_size(self, width=None, height=None):
        """        Get the width and height in pixels for the specified image.
        The values of @width and @height are returned as -1 if the
        values cannot be obtained (for instance, if the object is not onscreen).
        @param width: filled with the image width, or -1 if the value cannot be obtained.
        @param height: filled with the image height, or -1 if the value cannot be obtained.
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_image_description(self, description=None):
        """        Sets the textual description for this image.
        @param description: a string description to set for @image
        @type description: str
        @returns: boolean TRUE, or FALSE if operation could not be completed.
        @rtype: bool
        """
        return object


class ImageIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_image_position(self):
        return object

    @property
    def get_image_description(self):
        return object

    @property
    def get_image_size(self):
        return object

    @property
    def set_image_description(self):
        return object

    @property
    def get_image_locale(self):
        return object


class Implementor():
    """"""
    
    def ref_accessible(self):
        """        Gets a reference to an object's #AtkObject implementation, if
        the object implements #AtkObjectIface
        @returns: a reference to an object's #AtkObject implementation
        @rtype: Object
        """
        return object


class ImplementorIface():
    """The AtkImplementor interface is implemented by objects for which
AtkObject peers may be obtained via calls to
iface->(ref_accessible)(implementor);"""


class KeyEventStruct():
    """Encapsulates information about a key event."""

    @property
    def type(self):
        return object

    @property
    def state(self):
        return object

    @property
    def keyval(self):
        return object

    @property
    def length(self):
        return object

    @property
    def string(self):
        return object

    @property
    def keycode(self):
        return object

    @property
    def timestamp(self):
        return object


class Misc(GObject.Object):
    """A set of utility functions for thread locking. This interface and
all his related methods are deprecated since 2.12."""
    @staticmethod
    def get_instance():
        """        Obtain the singleton instance of AtkMisc for this application.
        @returns: The singleton instance of AtkMisc for this application.
        @rtype: Misc
        """
        return object
    
    def threads_enter(self):
        """        Take the thread mutex for the GUI toolkit,
        if one exists.
        (This method is implemented by the toolkit ATK implementation layer;
         for instance, for GTK+, GAIL implements this via GDK_THREADS_ENTER).
        @returns: 
        @rtype: None
        """
        return object
    
    def threads_leave(self):
        """        Release the thread mutex for the GUI toolkit,
        if one exists. This method, and atk_misc_threads_enter,
        are needed in some situations by threaded application code which
        services ATK requests, since fulfilling ATK requests often
        requires calling into the GUI toolkit.  If a long-running or
        potentially blocking call takes place inside such a block, it should
        be bracketed by atk_misc_threads_leave/atk_misc_threads_enter calls.
        (This method is implemented by the toolkit ATK implementation layer;
         for instance, for GTK+, GAIL implements this via GDK_THREADS_LEAVE).
        @returns: 
        @rtype: None
        """
        return object
    
    def threads_enter(self):
        """        Take the thread mutex for the GUI toolkit,
        if one exists.
        (This method is implemented by the toolkit ATK implementation layer;
         for instance, for GTK+, GAIL implements this via GDK_THREADS_ENTER).
        @returns: 
        @rtype: None
        """
        return object
    
    def threads_leave(self):
        """        Release the thread mutex for the GUI toolkit,
        if one exists. This method, and atk_misc_threads_enter,
        are needed in some situations by threaded application code which
        services ATK requests, since fulfilling ATK requests often
        requires calling into the GUI toolkit.  If a long-running or
        potentially blocking call takes place inside such a block, it should
        be bracketed by atk_misc_threads_leave/atk_misc_threads_enter calls.
        (This method is implemented by the toolkit ATK implementation layer;
         for instance, for GTK+, GAIL implements this via GDK_THREADS_LEAVE).
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object


class MiscClass():
    """Usage of AtkMisc is deprecated since 2.12 and heavily discouraged."""

    @property
    def parent(self):
        return object

    @property
    def threads_enter(self):
        return object

    @property
    def threads_leave(self):
        return object

    @property
    def vfuncs(self):
        return object


class NoOpObjectClass():
    """"""

    @property
    def parent_class(self):
        return object


class NoOpObjectFactoryClass():
    """"""

    @property
    def parent_class(self):
        return object


class Object(GObject.Object):
    """This class is the primary class for accessibility support via the
Accessibility ToolKit (ATK).  Objects which are instances of
#AtkObject (or instances of AtkObject-derived types) are queried
for properties which relate basic (and generic) properties of a UI
component such as name and description.  Instances of #AtkObject
may also be queried as to whether they implement other ATK
interfaces (e.g. #AtkAction, #AtkComponent, etc.), as appropriate
to the role which a given UI component plays in a user interface.

All UI components in an application which provide useful
information or services to the user must provide corresponding
#AtkObject instances on request (in GTK+, for instance, usually on
a call to #gtk_widget_get_accessible ()), either via ATK support
built into the toolkit for the widget class or ancestor class, or
in the case of custom widgets, if the inherited #AtkObject
implementation is insufficient, via instances of a new #AtkObject
subclass.

See also: #AtkObjectFactory, #AtkRegistry.  (GTK+ users see also
#GtkAccessible)."""
    
    def active_descendant_changed(self, child=None):
        """        
        @type child: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def children_changed(self, change_index=None, changed_child=None):
        """        
        @type change_index: int
        @type changed_child: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def connect_property_change_handler(self, handler=None):
        """        
        @param handler: a function to be called when a property changes its value
        @type handler: PropertyChangeHandler
        @returns: a #guint which is the handler id used in atk_object_remove_property_change_handler()
        @rtype: int
        """
        return object
    
    def focus_event(self, focus_in=None):
        """        
        @type focus_in: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def get_attributes(self):
        """        Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
        name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
        as distinct from strongly-typed object data available via other get/set methods.
        Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
        @returns: an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_description(self):
        """        Gets the accessible description of the accessible.
        @returns: a character string representing the accessible description of the accessible.
        @rtype: str
        """
        return object
    
    def get_index_in_parent(self):
        """        Gets the 0-based index of this accessible in its parent; returns -1 if the
        accessible does not have an accessible parent.
        @returns: an integer which is the index of the accessible in its parent
        @rtype: int
        """
        return object
    
    def get_layer(self):
        """        Gets the layer of the accessible.
        @returns: an #AtkLayer which is the layer of the accessible
        @rtype: Layer
        """
        return object
    
    def get_mdi_zorder(self):
        """        Gets the zorder of the accessible. The value G_MININT will be returned
        if the layer of the accessible is not ATK_LAYER_MDI.
        @returns: a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
        @rtype: int
        """
        return object
    
    def get_n_children(self):
        """        
        @returns: 
        @rtype: int
        """
        return object
    
    def get_name(self):
        """        Gets the accessible name of the accessible.
        @returns: a character string representing the accessible name of the object.
        @rtype: str
        """
        return object
    
    def get_object_locale(self):
        """        Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
        of @accessible.
        @returns: a UTF-8 string indicating the POSIX-style LC_MESSAGES
          locale of @accessible.
        @rtype: str
        """
        return object
    
    def get_parent(self):
        """        Gets the accessible parent of the accessible. By default this is
        the one assigned with atk_object_set_parent(), but it is assumed
        that ATK implementors have ways to get the parent of the object
        without the need of assigning it manually with
        atk_object_set_parent(), and will return it with this method.
        
        If you are only interested on the parent assigned with
        atk_object_set_parent(), use atk_object_peek_parent().
        @returns: an #AtkObject representing the accessible parent of the accessible
        @rtype: Object
        """
        return object
    
    def get_role(self):
        """        Gets the role of the accessible.
        @returns: an #AtkRole which is the role of the accessible
        @rtype: Role
        """
        return object
    
    def initialize(self, data=None):
        """        This function is called when implementing subclasses of #AtkObject.
        It does initialization required for the new object. It is intended
        that this function should called only in the ..._new() functions used
        to create an instance of a subclass of #AtkObject
        @param data: a #gpointer which identifies the object for which the AtkObject was created.
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def property_change(self, values=None):
        """        
        @type values: PropertyValues
        @returns: 
        @rtype: None
        """
        return object
    
    def ref_child(self, i=None):
        """        
        @type i: int
        @returns: 
        @rtype: Object
        """
        return object
    
    def ref_relation_set(self):
        """        Gets the #AtkRelationSet associated with the object.
        @returns: an #AtkRelationSet representing the relation set of the object.
        @rtype: RelationSet
        """
        return object
    
    def ref_state_set(self):
        """        Gets a reference to the state set of the accessible; the caller must
        unreference it when it is no longer needed.
        @returns: a reference to an #AtkStateSet which is the state set of the accessible
        @rtype: StateSet
        """
        return object
    
    def remove_property_change_handler(self, handler_id=None):
        """        
        @param handler_id: a guint which identifies the handler to be removed.
        @type handler_id: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_description(self, description=None):
        """        Sets the accessible description of the accessible. You can't set
        the description to NULL. This is reserved for the initial value. In
        this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
        the name to a empty value you can use "".
        @param description: a character string to be set as the accessible description
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_name(self, name=None):
        """        Sets the accessible name of the accessible. You can't set the name
        to NULL. This is reserved for the initial value. In this aspect
        NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
        a empty value you can use "".
        @param name: a character string to be set as the accessible name
        @type name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_parent(self, parent=None):
        """        Sets the accessible parent of the accessible. @parent can be NULL.
        @param parent: an #AtkObject to be set as the accessible parent
        @type parent: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_role(self, role=None):
        """        Sets the role of the accessible.
        @param role: an #AtkRole to be set as the role
        @type role: Role
        @returns: 
        @rtype: None
        """
        return object
    
    def state_change(self, name=None, state_set=None):
        """        
        @type name: str
        @type state_set: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def visible_data_changed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def add_relationship(self, relationship=None, target=None):
        """        Adds a relationship of the specified type with the specified target.
        @param relationship: The #AtkRelationType of the relation
        @param target: The #AtkObject which is to be the target of the relation.
        @type relationship: RelationType
        @type target: Object
        @returns: TRUE if the relationship is added.
        @rtype: bool
        """
        return object
    
    def connect_property_change_handler(self, handler=None):
        """        
        @param handler: a function to be called when a property changes its value
        @type handler: PropertyChangeHandler
        @returns: a #guint which is the handler id used in atk_object_remove_property_change_handler()
        @rtype: int
        """
        return object
    
    def get_attributes(self):
        """        Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
        name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
        as distinct from strongly-typed object data available via other get/set methods.
        Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
        @returns: an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_description(self):
        """        Gets the accessible description of the accessible.
        @returns: a character string representing the accessible description of the accessible.
        @rtype: str
        """
        return object
    
    def get_index_in_parent(self):
        """        Gets the 0-based index of this accessible in its parent; returns -1 if the
        accessible does not have an accessible parent.
        @returns: an integer which is the index of the accessible in its parent
        @rtype: int
        """
        return object
    
    def get_layer(self):
        """        Gets the layer of the accessible.
        @returns: an #AtkLayer which is the layer of the accessible
        @rtype: Layer
        """
        return object
    
    def get_mdi_zorder(self):
        """        Gets the zorder of the accessible. The value G_MININT will be returned
        if the layer of the accessible is not ATK_LAYER_MDI.
        @returns: a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
        @rtype: int
        """
        return object
    
    def get_n_accessible_children(self):
        """        Gets the number of accessible children of the accessible.
        @returns: an integer representing the number of accessible children of the accessible.
        @rtype: int
        """
        return object
    
    def get_name(self):
        """        Gets the accessible name of the accessible.
        @returns: a character string representing the accessible name of the object.
        @rtype: str
        """
        return object
    
    def get_object_locale(self):
        """        Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
        of @accessible.
        @returns: a UTF-8 string indicating the POSIX-style LC_MESSAGES
          locale of @accessible.
        @rtype: str
        """
        return object
    
    def get_parent(self):
        """        Gets the accessible parent of the accessible. By default this is
        the one assigned with atk_object_set_parent(), but it is assumed
        that ATK implementors have ways to get the parent of the object
        without the need of assigning it manually with
        atk_object_set_parent(), and will return it with this method.
        
        If you are only interested on the parent assigned with
        atk_object_set_parent(), use atk_object_peek_parent().
        @returns: an #AtkObject representing the accessible parent of the accessible
        @rtype: Object
        """
        return object
    
    def get_role(self):
        """        Gets the role of the accessible.
        @returns: an #AtkRole which is the role of the accessible
        @rtype: Role
        """
        return object
    
    def initialize(self, data=None):
        """        This function is called when implementing subclasses of #AtkObject.
        It does initialization required for the new object. It is intended
        that this function should called only in the ..._new() functions used
        to create an instance of a subclass of #AtkObject
        @param data: a #gpointer which identifies the object for which the AtkObject was created.
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def notify_state_change(self, state=None, value=None):
        """        Emits a state-change signal for the specified state.
        
        Note that as a general rule when the state of an existing object changes,
        emitting a notification is expected.
        @param state: an #AtkState whose state is changed
        @param value: a gboolean which indicates whether the state is being set on or off
        @type state: State
        @type value: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def peek_parent(self):
        """        Gets the accessible parent of the accessible, if it has been
        manually assigned with atk_object_set_parent. Otherwise, this
        function returns %NULL.
        
        This method is intended as an utility for ATK implementors, and not
        to be exposed to accessible tools. See atk_object_get_parent() for
        further reference.
        @returns: an #AtkObject representing the accessible parent of the accessible if assigned
        @rtype: Object
        """
        return object
    
    def ref_accessible_child(self, i=None):
        """        Gets a reference to the specified accessible child of the object.
        The accessible children are 0-based so the first accessible child is
        at index 0, the second at index 1 and so on.
        @param i: a gint representing the position of the child, starting from 0
        @type i: int
        @returns: an #AtkObject representing the specified accessible child of the accessible.
        @rtype: Object
        """
        return object
    
    def ref_relation_set(self):
        """        Gets the #AtkRelationSet associated with the object.
        @returns: an #AtkRelationSet representing the relation set of the object.
        @rtype: RelationSet
        """
        return object
    
    def ref_state_set(self):
        """        Gets a reference to the state set of the accessible; the caller must
        unreference it when it is no longer needed.
        @returns: a reference to an #AtkStateSet which is the state set of the accessible
        @rtype: StateSet
        """
        return object
    
    def remove_property_change_handler(self, handler_id=None):
        """        
        @param handler_id: a guint which identifies the handler to be removed.
        @type handler_id: int
        @returns: 
        @rtype: None
        """
        return object
    
    def remove_relationship(self, relationship=None, target=None):
        """        Removes a relationship of the specified type with the specified target.
        @param relationship: The #AtkRelationType of the relation
        @param target: The #AtkObject which is the target of the relation to be removed.
        @type relationship: RelationType
        @type target: Object
        @returns: TRUE if the relationship is removed.
        @rtype: bool
        """
        return object
    
    def set_description(self, description=None):
        """        Sets the accessible description of the accessible. You can't set
        the description to NULL. This is reserved for the initial value. In
        this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
        the name to a empty value you can use "".
        @param description: a character string to be set as the accessible description
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_name(self, name=None):
        """        Sets the accessible name of the accessible. You can't set the name
        to NULL. This is reserved for the initial value. In this aspect
        NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
        a empty value you can use "".
        @param name: a character string to be set as the accessible name
        @type name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_parent(self, parent=None):
        """        Sets the accessible parent of the accessible. @parent can be NULL.
        @param parent: an #AtkObject to be set as the accessible parent
        @type parent: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_role(self, role=None):
        """        Sets the role of the accessible.
        @param role: an #AtkRole to be set as the role
        @type role: Role
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def description(self):
        return object

    @property
    def name(self):
        return object

    @property
    def accessible_parent(self):
        return object

    @property
    def role(self):
        return object

    @property
    def relation_set(self):
        return object

    @property
    def layer(self):
        return object


class ObjectClass():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_name(self):
        return object

    @property
    def get_description(self):
        return object

    @property
    def get_parent(self):
        return object

    @property
    def get_n_children(self):
        return object

    @property
    def ref_child(self):
        return object

    @property
    def get_index_in_parent(self):
        return object

    @property
    def ref_relation_set(self):
        return object

    @property
    def get_role(self):
        return object

    @property
    def get_layer(self):
        return object

    @property
    def get_mdi_zorder(self):
        return object

    @property
    def ref_state_set(self):
        return object

    @property
    def set_name(self):
        return object

    @property
    def set_description(self):
        return object

    @property
    def set_parent(self):
        return object

    @property
    def set_role(self):
        return object

    @property
    def connect_property_change_handler(self):
        return object

    @property
    def remove_property_change_handler(self):
        return object

    @property
    def initialize(self):
        return object

    @property
    def children_changed(self):
        return object

    @property
    def focus_event(self):
        return object

    @property
    def property_change(self):
        return object

    @property
    def state_change(self):
        return object

    @property
    def visible_data_changed(self):
        return object

    @property
    def active_descendant_changed(self):
        return object

    @property
    def get_attributes(self):
        return object

    @property
    def get_object_locale(self):
        return object

    @property
    def pad1(self):
        return object


class ObjectFactory(GObject.Object):
    """This class is the base object class for a factory used to create an
accessible object for a specific GType. The function
atk_registry_set_factory_type() is normally called to store in the
registry the factory type to be used to create an accessible of a
particular GType."""
    
    def invalidate(self):
        """        Inform @factory that it is no longer being used to create
        accessibles. When called, @factory may need to inform
        #AtkObjects which it has created that they need to be re-instantiated.
        Note: primarily used for runtime replacement of #AtkObjectFactorys
        in object registries.
        @returns: 
        @rtype: None
        """
        return object
    
    def create_accessible(self, obj=None):
        """        Provides an #AtkObject that implements an accessibility interface
        on behalf of @obj
        @param obj: a #GObject
        @type obj: GObject.Object
        @returns: an #AtkObject that implements an accessibility interface on behalf of @obj
        @rtype: Object
        """
        return object
    
    def get_accessible_type(self):
        """        Gets the GType of the accessible which is created by the factory.
        @returns: the type of the accessible which is created by the @factory. The value G_TYPE_INVALID is returned if no type if found.
        @rtype: GType
        """
        return object
    
    def invalidate(self):
        """        Inform @factory that it is no longer being used to create
        accessibles. When called, @factory may need to inform
        #AtkObjects which it has created that they need to be re-instantiated.
        Note: primarily used for runtime replacement of #AtkObjectFactorys
        in object registries.
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object


class ObjectFactoryClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def create_accessible(self):
        return object

    @property
    def invalidate(self):
        return object

    @property
    def get_accessible_type(self):
        return object

    @property
    def pad1(self):
        return object

    @property
    def pad2(self):
        return object


class Plug(Object, Component):
    """See #AtkSocket"""
    
    def __init__(self):
        """        
        @returns: Newly created Plug
        @rtype: Plug
        """
        return object
    @staticmethod
    def new():
        """        
        @returns: Newly created Plug
        @rtype: Plug
        """
        return object
    
    def get_object_id(self):
        """        
        @returns: 
        @rtype: str
        """
        return object
    
    def get_id(self):
        """        Gets the unique ID of an #AtkPlug object, which can be used to
        embed inside of an #AtkSocket using atk_socket_embed().
        
        Internally, this calls a class function that should be registered
        by the IPC layer (usually at-spi2-atk). The implementor of an
        #AtkPlug object should call this function (after atk-bridge is
        loaded) and pass the value to the process implementing the
        #AtkSocket, so it could embed the plug.
        @returns: the unique ID for the plug
        @rtype: str
        """
        return object

    @property
    def parent(self):
        return object


class PlugClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def get_object_id(self):
        return object


class PropertyValues():
    """Note: @old_value field of #AtkPropertyValues will not contain a
valid value. This is a field defined with the purpose of contain
the previous value of the property, but is not used anymore."""

    @property
    def property_name(self):
        return object

    @property
    def old_value(self):
        return object

    @property
    def new_value(self):
        return object


class Range():
    """#AtkRange are used on #AtkValue, in order to represent the full
range of a given component (for example an slider or a range
control), or to define each individual subrange this full range is
splitted if available. See #AtkValue documentation for further
details."""
    
    def __init__(self, lower_limit=None, upper_limit=None, description=None):
        """        Creates a new #AtkRange.
        @param lower_limit: inferior limit for this range
        @param upper_limit: superior limit for this range
        @param description: human readable description of this range.
        @type lower_limit: float
        @type upper_limit: float
        @type description: str
        @returns: Newly created Range
        @rtype: Range
        """
        return object
    @staticmethod
    def new(lower_limit=None, upper_limit=None, description=None):
        """        Creates a new #AtkRange.
        @param lower_limit: inferior limit for this range
        @param upper_limit: superior limit for this range
        @param description: human readable description of this range.
        @type lower_limit: float
        @type upper_limit: float
        @type description: str
        @returns: Newly created Range
        @rtype: Range
        """
        return object
    
    def copy(self):
        """        Returns a new #AtkRange that is a exact copy of @src
        @returns: a new #AtkRange copy of @src
        @rtype: Range
        """
        return object
    
    def free(self):
        """        Free @range
        @returns: 
        @rtype: None
        """
        return object
    
    def get_description(self):
        """        Returns the human readable description of @range
        @returns: the human-readable description of @range
        @rtype: str
        """
        return object
    
    def get_lower_limit(self):
        """        Returns the lower limit of @range
        @returns: the lower limit of @range
        @rtype: float
        """
        return object
    
    def get_upper_limit(self):
        """        Returns the upper limit of @range
        @returns: the upper limit of @range
        @rtype: float
        """
        return object


class Rectangle():
    """A data structure for holding a rectangle. Those coordinates are
relative to the component top-level parent."""

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object


class Registry(GObject.Object):
    """The AtkRegistry is normally used to create appropriate ATK "peers"
for user interface components.  Application developers usually need
only interact with the AtkRegistry by associating appropriate ATK
implementation classes with GObject classes via the
atk_registry_set_factory_type call, passing the appropriate GType
for application custom widget classes."""
    
    def get_factory(self, type=None):
        """        Gets an #AtkObjectFactory appropriate for creating #AtkObjects
        appropriate for @type.
        @param type: a #GType with which to look up the associated #AtkObjectFactory
        @type type: GType
        @returns: an #AtkObjectFactory appropriate for creating #AtkObjects appropriate for @type.
        @rtype: ObjectFactory
        """
        return object
    
    def get_factory_type(self, type=None):
        """        Provides a #GType indicating the #AtkObjectFactory subclass
        associated with @type.
        @param type: a #GType with which to look up the associated #AtkObjectFactory subclass
        @type type: GType
        @returns: a #GType associated with type @type
        @rtype: GType
        """
        return object
    
    def set_factory_type(self, type=None, factory_type=None):
        """        Associate an #AtkObjectFactory subclass with a #GType. Note:
        The associated @factory_type will thereafter be responsible for
        the creation of new #AtkObject implementations for instances
        appropriate for @type.
        @param type: an #AtkObject type
        @param factory_type: an #AtkObjectFactory type to associate with @type.  Must implement AtkObject appropriate for @type.
        @type type: GType
        @type factory_type: GType
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def factory_type_registry(self):
        return object

    @property
    def factory_singleton_cache(self):
        return object


class RegistryClass():
    """"""

    @property
    def parent_class(self):
        return object


class Relation(GObject.Object):
    """An AtkRelation describes a relation between an object and one or
more other objects. The actual relations that an object has with
other objects are defined as an AtkRelationSet, which is a set of
AtkRelations."""
    
    def __init__(self, targets=None, n_targets=None, relationship=None):
        """        Create a new relation for the specified key and the specified list
        of targets.  See also atk_object_add_relationship().
        @param targets: an array of pointers to  #AtkObjects
        @param n_targets: number of #AtkObjects pointed to by @targets
        @param relationship: an #AtkRelationType with which to create the new  #AtkRelation
        @type n_targets: int
        @type relationship: RelationType
        @returns: Newly created Relation
        @rtype: Relation
        """
        return object
    @staticmethod
    def new(targets=None, n_targets=None, relationship=None):
        """        Create a new relation for the specified key and the specified list
        of targets.  See also atk_object_add_relationship().
        @param targets: an array of pointers to  #AtkObjects
        @param n_targets: number of #AtkObjects pointed to by @targets
        @param relationship: an #AtkRelationType with which to create the new  #AtkRelation
        @type n_targets: int
        @type relationship: RelationType
        @returns: Newly created Relation
        @rtype: Relation
        """
        return object
    
    def add_target(self, target=None):
        """        Adds the specified AtkObject to the target for the relation, if it is
        not already present.  See also atk_object_add_relationship().
        @param target: an #AtkObject
        @type target: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def get_relation_type(self):
        """        Gets the type of @relation
        @returns: the type of @relation
        @rtype: RelationType
        """
        return object
    
    def get_target(self):
        """        Gets the target list of @relation
        @rtype: None
        """
        return object
    
    def remove_target(self, target=None):
        """        Remove the specified AtkObject from the target for the relation.
        @param target: an #AtkObject
        @type target: Object
        @returns: TRUE if the removal is successful.
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def target(self):
        return object

    @property
    def relationship(self):
        return object


class RelationClass():
    """"""

    @property
    def parent(self):
        return object


class RelationSet(GObject.Object):
    """The AtkRelationSet held by an object establishes its relationships
with objects beyond the normal "parent/child" hierarchical
relationships that all user interface objects have.
AtkRelationSets establish whether objects are labelled or
controlled by other components, share group membership with other
components (for instance within a radio-button group), or share
content which "flows" between them, among other types of possible
relationships."""
    
    def __init__(self):
        """        Creates a new empty relation set.
        @returns: Newly created RelationSet
        @rtype: RelationSet
        """
        return object
    @staticmethod
    def new():
        """        Creates a new empty relation set.
        @returns: Newly created RelationSet
        @rtype: RelationSet
        """
        return object
    
    def add(self, relation=None):
        """        Add a new relation to the current relation set if it is not already
        present.
        This function ref's the AtkRelation so the caller of this function
        should unref it to ensure that it will be destroyed when the AtkRelationSet
        is destroyed.
        @param relation: an #AtkRelation
        @type relation: Relation
        @returns: 
        @rtype: None
        """
        return object
    
    def add_relation_by_type(self, relationship=None, target=None):
        """        Add a new relation of the specified type with the specified target to
        the current relation set if the relation set does not contain a relation
        of that type. If it is does contain a relation of that typea the target
        is added to the relation.
        @param relationship: an #AtkRelationType
        @param target: an #AtkObject
        @type relationship: RelationType
        @type target: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def contains(self, relationship=None):
        """        Determines whether the relation set contains a relation that matches the
        specified type.
        @param relationship: an #AtkRelationType
        @type relationship: RelationType
        @returns: %TRUE if @relationship is the relationship type of a relation in @set, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def contains_target(self, relationship=None, target=None):
        """        Determines whether the relation set contains a relation that
        matches the specified pair formed by type @relationship and object
        @target.
        @param relationship: an #AtkRelationType
        @param target: an #AtkObject
        @type relationship: RelationType
        @type target: Object
        @returns: %TRUE if @set contains a relation with the relationship type @relationship with an object @target, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def get_n_relations(self):
        """        Determines the number of relations in a relation set.
        @returns: an integer representing the number of relations in the set.
        @rtype: int
        """
        return object
    
    def get_relation(self, i=None):
        """        Determines the relation at the specified position in the relation set.
        @param i: a gint representing a position in the set, starting from 0.
        @type i: int
        @returns: a #AtkRelation, which is the relation at position i in the set.
        @rtype: Relation
        """
        return object
    
    def get_relation_by_type(self, relationship=None):
        """        Finds a relation that matches the specified type.
        @param relationship: an #AtkRelationType
        @type relationship: RelationType
        @returns: an #AtkRelation, which is a relation matching the specified type.
        @rtype: Relation
        """
        return object
    
    def remove(self, relation=None):
        """        Removes a relation from the relation set.
        This function unref's the #AtkRelation so it will be deleted unless there
        is another reference to it.
        @param relation: an #AtkRelation
        @type relation: Relation
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def relations(self):
        return object


class RelationSetClass():
    """"""

    @property
    def parent(self):
        return object

    @property
    def pad1(self):
        return object

    @property
    def pad2(self):
        return object


class Selection():
    """#AtkSelection should be implemented by UI components with children
which are exposed by #atk_object_ref_child and
#atk_object_get_n_children, if the use of the parent UI component
ordinarily involves selection of one or more of the objects
corresponding to those #AtkObject children - for example,
selectable lists.

Note that other types of "selection" (for instance text selection)
are accomplished a other ATK interfaces - #AtkSelection is limited
to the selection/deselection of children."""
    
    def add_selection(self, i=None):
        """        Adds the specified accessible child of the object to the
        object's selection.
        @param i: a #gint specifying the child index.
        @type i: int
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def clear_selection(self):
        """        Clears the selection in the object so that no children in the object
        are selected.
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_selection_count(self):
        """        Gets the number of accessible children currently selected.
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @returns: a gint representing the number of items selected, or 0 if @selection does not implement this interface.
        @rtype: int
        """
        return object
    
    def is_child_selected(self, i=None):
        """        Determines if the current child of this object is selected
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @param i: a #gint specifying the child index.
        @type i: int
        @returns: a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
        @rtype: bool
        """
        return object
    
    def ref_selection(self, i=None):
        """        Gets a reference to the accessible object representing the specified
        selected child of the object.
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @param i: a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
        @type i: int
        @returns: an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
        @rtype: Object
        """
        return object
    
    def remove_selection(self, i=None):
        """        Removes the specified child of the object from the object's selection.
        @param i: a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
        @type i: int
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def select_all_selection(self):
        """        Causes every child of the object to be selected if the object
        supports multiple selections.
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def selection_changed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def add_selection(self, i=None):
        """        Adds the specified accessible child of the object to the
        object's selection.
        @param i: a #gint specifying the child index.
        @type i: int
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def clear_selection(self):
        """        Clears the selection in the object so that no children in the object
        are selected.
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_selection_count(self):
        """        Gets the number of accessible children currently selected.
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @returns: a gint representing the number of items selected, or 0 if @selection does not implement this interface.
        @rtype: int
        """
        return object
    
    def is_child_selected(self, i=None):
        """        Determines if the current child of this object is selected
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @param i: a #gint specifying the child index.
        @type i: int
        @returns: a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
        @rtype: bool
        """
        return object
    
    def ref_selection(self, i=None):
        """        Gets a reference to the accessible object representing the specified
        selected child of the object.
        Note: callers should not rely on %NULL or on a zero value for
        indication of whether AtkSelectionIface is implemented, they should
        use type checking/interface checking macros or the
        atk_get_accessible_value() convenience method.
        @param i: a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
        @type i: int
        @returns: an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
        @rtype: Object
        """
        return object
    
    def remove_selection(self, i=None):
        """        Removes the specified child of the object from the object's selection.
        @param i: a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
        @type i: int
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def select_all_selection(self):
        """        Causes every child of the object to be selected if the object
        supports multiple selections.
        @returns: TRUE if success, FALSE otherwise.
        @rtype: bool
        """
        return object


class SelectionIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def add_selection(self):
        return object

    @property
    def clear_selection(self):
        return object

    @property
    def ref_selection(self):
        return object

    @property
    def get_selection_count(self):
        return object

    @property
    def is_child_selected(self):
        return object

    @property
    def remove_selection(self):
        return object

    @property
    def select_all_selection(self):
        return object

    @property
    def selection_changed(self):
        return object


class Socket(Object, Component):
    """Together with #AtkPlug, #AtkSocket provides the ability to embed
accessibles from one process into another in a fashion that is
transparent to assistive technologies. #AtkSocket works as the
container of #AtkPlug, embedding it using the method
atk_socket_embed(). Any accessible contained in the #AtkPlug will
appear to the assistive technologies as being inside the
application that created the #AtkSocket.

The communication between a #AtkSocket and a #AtkPlug is done by
the IPC layer of the accessibility framework, normally implemented
by the D-Bus based implementation of AT-SPI (at-spi2). If that is
the case, at-spi-atk2 is the responsible to implement the abstract
methods atk_plug_get_id() and atk_socket_embed(), so an ATK
implementor shouldn't reimplement them. The process that contains
the #AtkPlug is responsible to send the ID returned by
atk_plug_id() to the process that contains the #AtkSocket, so it
could call the method atk_socket_embed() in order to embed it.

For the same reasons, an implementor doesn't need to implement
atk_object_get_n_accessible_children() and
atk_object_ref_accessible_child(). All the logic related to those
functions will be implemented by the IPC layer."""
    
    def __init__(self):
        """        
        @returns: Newly created Socket
        @rtype: Socket
        """
        return object
    @staticmethod
    def new():
        """        
        @returns: Newly created Socket
        @rtype: Socket
        """
        return object
    
    def embed(self, plug_id=None):
        """        Embeds the children of an #AtkPlug as the children of the
        #AtkSocket. The plug may be in the same process or in a different
        process.
        
        The class item used by this function should be filled in by the IPC
        layer (usually at-spi2-atk). The implementor of the AtkSocket
        should call this function and pass the id for the plug as returned
        by atk_plug_get_id().  It is the responsibility of the application
        to pass the plug id on to the process implementing the #AtkSocket
        as needed.
        @param plug_id: the ID of an #AtkPlug
        @type plug_id: str
        @returns: 
        @rtype: None
        """
        return object
    
    def embed(self, plug_id=None):
        """        Embeds the children of an #AtkPlug as the children of the
        #AtkSocket. The plug may be in the same process or in a different
        process.
        
        The class item used by this function should be filled in by the IPC
        layer (usually at-spi2-atk). The implementor of the AtkSocket
        should call this function and pass the id for the plug as returned
        by atk_plug_get_id().  It is the responsibility of the application
        to pass the plug id on to the process implementing the #AtkSocket
        as needed.
        @param plug_id: the ID of an #AtkPlug
        @type plug_id: str
        @returns: 
        @rtype: None
        """
        return object
    
    def is_occupied(self):
        """        Determines whether or not the socket has an embedded plug.
        @returns: TRUE if a plug is embedded in the socket
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def embedded_plug_id(self):
        return object


class SocketClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def embed(self):
        return object


class StateSet(GObject.Object):
    """An AtkStateSet is a read-only representation of the full set of #AtkStates
that apply to an object at a given time. This set is not meant to be
modified, but rather created when #atk_object_ref_state_set() is called."""
    
    def __init__(self):
        """        Creates a new empty state set.
        @returns: Newly created StateSet
        @rtype: StateSet
        """
        return object
    @staticmethod
    def new():
        """        Creates a new empty state set.
        @returns: Newly created StateSet
        @rtype: StateSet
        """
        return object
    
    def add_state(self, type=None):
        """        Adds the state of the specified type to the state set if it is not already
        present.
        
        Note that because an #AtkStateSet is a read-only object, this method should
        be used to add a state to a newly-created set which will then be returned by
        #atk_object_ref_state_set. It should not be used to modify the existing state
        of an object. See also #atk_object_notify_state_change.
        @param type: an #AtkStateType
        @type type: StateType
        @returns: %TRUE if  the state for @type is not already in @set.
        @rtype: bool
        """
        return object
    
    def add_states(self, types=None, n_types=None):
        """        Adds the states of the specified types to the state set.
        
        Note that because an #AtkStateSet is a read-only object, this method should
        be used to add states to a newly-created set which will then be returned by
        #atk_object_ref_state_set. It should not be used to modify the existing state
        of an object. See also #atk_object_notify_state_change.
        @param types: an array of #AtkStateType
        @param n_types: The number of elements in the array
        @type n_types: int
        @returns: 
        @rtype: None
        """
        return object
    
    def and_sets(self, compare_set=None):
        """        Constructs the intersection of the two sets, returning %NULL if the
        intersection is empty.
        @param compare_set: another #AtkStateSet
        @type compare_set: StateSet
        @returns: a new #AtkStateSet which is the intersection of the two sets.
        @rtype: StateSet
        """
        return object
    
    def clear_states(self):
        """        Removes all states from the state set.
        @returns: 
        @rtype: None
        """
        return object
    
    def contains_state(self, type=None):
        """        Checks whether the state for the specified type is in the specified set.
        @param type: an #AtkStateType
        @type type: StateType
        @returns: %TRUE if @type is the state type is in @set.
        @rtype: bool
        """
        return object
    
    def contains_states(self, types=None, n_types=None):
        """        Checks whether the states for all the specified types are in the
        specified set.
        @param types: an array of #AtkStateType
        @param n_types: The number of elements in the array
        @type n_types: int
        @returns: %TRUE if all the states for @type are in @set.
        @rtype: bool
        """
        return object
    
    def is_empty(self):
        """        Checks whether the state set is empty, i.e. has no states set.
        @returns: %TRUE if @set has no states set, otherwise %FALSE
        @rtype: bool
        """
        return object
    
    def or_sets(self, compare_set=None):
        """        Constructs the union of the two sets.
        @param compare_set: another #AtkStateSet
        @type compare_set: StateSet
        @returns: a new #AtkStateSet which is the union of the two sets, returning %NULL is empty.
        @rtype: StateSet
        """
        return object
    
    def remove_state(self, type=None):
        """        Removes the state for the specified type from the state set.
        
        Note that because an #AtkStateSet is a read-only object, this method should
        be used to remove a state to a newly-created set which will then be returned
        by #atk_object_ref_state_set. It should not be used to modify the existing
        state of an object. See also #atk_object_notify_state_change.
        @param type: an #AtkType
        @type type: StateType
        @returns: %TRUE if @type was the state type is in @set.
        @rtype: bool
        """
        return object
    
    def xor_sets(self, compare_set=None):
        """        Constructs the exclusive-or of the two sets, returning %NULL is empty.
        The set returned by this operation contains the states in exactly
        one of the two sets.
        @param compare_set: another #AtkStateSet
        @type compare_set: StateSet
        @returns: a new #AtkStateSet which contains the states which are in exactly one of the two sets.
        @rtype: StateSet
        """
        return object

    @property
    def parent(self):
        return object


class StateSetClass():
    """"""

    @property
    def parent(self):
        return object


class StreamableContent():
    """An interface whereby an object allows its backing content to be
streamed to clients.  Typical implementors would be images or
icons, HTML content, or multimedia display/rendering widgets.

Negotiation of content type is allowed. Clients may examine the
backing data and transform, convert, or parse the content in order
to present it in an alternate form to end-users.

The AtkStreamableContent interface is particularly useful for
saving, printing, or post-processing entire documents, or for
persisting alternate views of a document. If document content
itself is being serialized, stored, or converted, then use of the
AtkStreamableContent interface can help address performance
issues. Unlike most ATK interfaces, this interface is not strongly
tied to the current user-agent view of the a particular document,
but may in some cases give access to the underlying model data."""
    
    def get_mime_type(self, i=None):
        """        Gets the character string of the specified mime type. The first mime
        type is at position 0, the second at position 1, and so on.
        @param i: a gint representing the position of the mime type starting from 0
        @type i: int
        @returns: a gchar* representing the specified mime type; the caller should not free the character string.
        @rtype: str
        """
        return object
    
    def get_n_mime_types(self):
        """        Gets the number of mime types supported by this object.
        @returns: a gint which is the number of mime types supported by the object.
        @rtype: int
        """
        return object
    
    def get_stream(self, mime_type=None):
        """        Gets the content in the specified mime type.
        @param mime_type: a gchar* representing the mime type
        @type mime_type: str
        @returns: A #GIOChannel which contains the content in the specified mime type.
        @rtype: GLib.IOChannel
        """
        return object
    
    def get_uri(self, mime_type=None):
        """        Get a string representing a URI in IETF standard format
        (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
        may be streamed in the specified mime-type, if one is available.
        If mime_type is NULL, the URI for the default (and possibly only) mime-type is
        returned.
        
        Note that it is possible for get_uri to return NULL but for
        get_stream to work nonetheless, since not all GIOChannels connect to URIs.
        @param mime_type: a gchar* representing the mime type, or NULL to request a URI for the default mime type.
        @type mime_type: str
        @returns: Returns a string representing a URI, or %NULL if no corresponding URI can be constructed.
        @rtype: str
        """
        return object
    
    def get_mime_type(self, i=None):
        """        Gets the character string of the specified mime type. The first mime
        type is at position 0, the second at position 1, and so on.
        @param i: a gint representing the position of the mime type starting from 0
        @type i: int
        @returns: a gchar* representing the specified mime type; the caller should not free the character string.
        @rtype: str
        """
        return object
    
    def get_n_mime_types(self):
        """        Gets the number of mime types supported by this object.
        @returns: a gint which is the number of mime types supported by the object.
        @rtype: int
        """
        return object
    
    def get_stream(self, mime_type=None):
        """        Gets the content in the specified mime type.
        @param mime_type: a gchar* representing the mime type
        @type mime_type: str
        @returns: A #GIOChannel which contains the content in the specified mime type.
        @rtype: GLib.IOChannel
        """
        return object
    
    def get_uri(self, mime_type=None):
        """        Get a string representing a URI in IETF standard format
        (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
        may be streamed in the specified mime-type, if one is available.
        If mime_type is NULL, the URI for the default (and possibly only) mime-type is
        returned.
        
        Note that it is possible for get_uri to return NULL but for
        get_stream to work nonetheless, since not all GIOChannels connect to URIs.
        @param mime_type: a gchar* representing the mime type, or NULL to request a URI for the default mime type.
        @type mime_type: str
        @returns: Returns a string representing a URI, or %NULL if no corresponding URI can be constructed.
        @rtype: str
        """
        return object


class StreamableContentIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_n_mime_types(self):
        return object

    @property
    def get_mime_type(self):
        return object

    @property
    def get_stream(self):
        return object

    @property
    def get_uri(self):
        return object

    @property
    def pad1(self):
        return object

    @property
    def pad2(self):
        return object

    @property
    def pad3(self):
        return object


class Table():
    """#AtkTable should be implemented by components which present
elements ordered via rows and columns.  It may also be used to
present tree-structured information if the nodes of the trees can
be said to contain multiple "columns".  Individual elements of an
#AtkTable are typically referred to as "cells". Those cells should
implement the interface #AtkTableCell, but #Atk doesn't require
them to be direct children of the current #AtkTable. They can be
grand-children, grand-grand-children etc. #AtkTable provides the
API needed to get a individual cell based on the row and column
numbers.

Children of #AtkTable are frequently "lightweight" objects, that
is, they may not have backing widgets in the host UI toolkit.  They
are therefore often transient.

Since tables are often very complex, #AtkTable includes provision
for offering simplified summary information, as well as row and
column headers and captions.  Headers and captions are #AtkObjects
which may implement other interfaces (#AtkText, #AtkImage, etc.) as
appropriate.  #AtkTable summaries may themselves be (simplified)
#AtkTables, etc.

Note for implementors: in the past, #AtkTable required that all the
cells should be direct children of #AtkTable, and provided some
index based methods to request the cells. The practice showed that
that forcing made #AtkTable implementation complex, and hard to
expose other kind of children, like rows or captions. Right now,
index-based methods are deprecated."""
    
    def add_column_selection(self, column=None):
        """        Adds the specified @column to the selection.
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def add_row_selection(self, row=None):
        """        Adds the specified @row to the selection.
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def column_deleted(self, column=None, num_deleted=None):
        """        
        @type column: int
        @type num_deleted: int
        @returns: 
        @rtype: None
        """
        return object
    
    def column_inserted(self, column=None, num_inserted=None):
        """        
        @type column: int
        @type num_inserted: int
        @returns: 
        @rtype: None
        """
        return object
    
    def column_reordered(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def get_caption(self):
        """        Gets the caption for the @table.
        @returns: a AtkObject* representing the table caption, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_column_at_index(self, index_=None):
        """        Gets a #gint representing the column at the specified @index_.
        @param index_: a #gint representing an index in @table
        @type index_: int
        @returns: a gint representing the column at the specified index, or -1 if the table does not implement this method.
        @rtype: int
        """
        return object
    
    def get_column_description(self, column=None):
        """        Gets the description text of the specified @column in the table
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gchar* representing the column description, or %NULL if value does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_column_extent_at(self, row=None, column=None):
        """        Gets the number of columns occupied by the accessible object
        at the specified @row and @column in the @table.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gint representing the column extent at specified position, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_column_header(self, column=None):
        """        Gets the column header of a specified column in an accessible table.
        @param column: a #gint representing a column in the table
        @type column: int
        @returns: a AtkObject* representing the specified column header, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_index_at(self, row=None, column=None):
        """        Gets a #gint representing the index at the specified @row and
        @column.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a #gint representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_n_columns(self):
        """        Gets the number of columns in the table.
        @returns: a gint representing the number of columns, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_n_rows(self):
        """        Gets the number of rows in the table.
        @returns: a gint representing the number of rows, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_row_at_index(self, index_=None):
        """        Gets a #gint representing the row at the specified @index_.
        @param index_: a #gint representing an index in @table
        @type index_: int
        @returns: a gint representing the row at the specified index, or -1 if the table does not implement this method.
        @rtype: int
        """
        return object
    
    def get_row_description(self, row=None):
        """        Gets the description text of the specified row in the table
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gchar* representing the row description, or %NULL if value does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_row_extent_at(self, row=None, column=None):
        """        Gets the number of rows occupied by the accessible object
        at a specified @row and @column in the @table.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gint representing the row extent at specified position, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_row_header(self, row=None):
        """        Gets the row header of a specified row in an accessible table.
        @param row: a #gint representing a row in the table
        @type row: int
        @returns: a AtkObject* representing the specified row header, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_selected_columns(self, selected=None):
        """        Gets the selected columns of the table by initializing **selected with
        the selected column numbers. This array should be freed by the caller.
        @param selected: a #gint** that is to contain the selected columns numbers
        @type selected: int
        @returns: a gint representing the number of selected columns, or %0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_selected_rows(self, selected=None):
        """        Gets the selected rows of the table by initializing **selected with
        the selected row numbers. This array should be freed by the caller.
        @param selected: a #gint** that is to contain the selected row numbers
        @type selected: int
        @returns: a gint representing the number of selected rows, or zero if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_summary(self):
        """        Gets the summary description of the table.
        @returns: a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def is_column_selected(self, column=None):
        """        Gets a boolean value indicating whether the specified @column
        is selected
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def is_row_selected(self, row=None):
        """        Gets a boolean value indicating whether the specified @row
        is selected
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if the row is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def is_selected(self, row=None, column=None):
        """        Gets a boolean value indicating whether the accessible object
        at the specified @row and @column is selected
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gboolean representing if the cell is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def model_changed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def ref_at(self, row=None, column=None):
        """        Get a reference to the table cell at @row, @column. This cell
        should implement the interface #AtkTableCell
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: an #AtkObject representing the referred to accessible
        @rtype: Object
        """
        return object
    
    def remove_column_selection(self, column=None):
        """        Adds the specified @column to the selection.
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def remove_row_selection(self, row=None):
        """        Removes the specified @row from the selection.
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def row_deleted(self, row=None, num_deleted=None):
        """        
        @type row: int
        @type num_deleted: int
        @returns: 
        @rtype: None
        """
        return object
    
    def row_inserted(self, row=None, num_inserted=None):
        """        
        @type row: int
        @type num_inserted: int
        @returns: 
        @rtype: None
        """
        return object
    
    def row_reordered(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def set_caption(self, caption=None):
        """        Sets the caption for the table.
        @param caption: a #AtkObject representing the caption to set for @table
        @type caption: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_column_description(self, column=None, description=None):
        """        Sets the description text for the specified @column of the @table.
        @param column: a #gint representing a column in @table
        @param description: a #gchar representing the description text to set for the specified @column of the @table
        @type column: int
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_column_header(self, column=None, header=None):
        """        Sets the specified column header to @header.
        @param column: a #gint representing a column in @table
        @param header: an #AtkTable
        @type column: int
        @type header: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_row_description(self, row=None, description=None):
        """        Sets the description text for the specified @row of @table.
        @param row: a #gint representing a row in @table
        @param description: a #gchar representing the description text to set for the specified @row of @table
        @type row: int
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_row_header(self, row=None, header=None):
        """        Sets the specified row header to @header.
        @param row: a #gint representing a row in @table
        @param header: an #AtkTable
        @type row: int
        @type header: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_summary(self, accessible=None):
        """        Sets the summary description of the table.
        @param accessible: an #AtkObject representing the summary description to set for @table
        @type accessible: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def add_column_selection(self, column=None):
        """        Adds the specified @column to the selection.
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def add_row_selection(self, row=None):
        """        Adds the specified @row to the selection.
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def get_caption(self):
        """        Gets the caption for the @table.
        @returns: a AtkObject* representing the table caption, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_column_at_index(self, index_=None):
        """        Gets a #gint representing the column at the specified @index_.
        @param index_: a #gint representing an index in @table
        @type index_: int
        @returns: a gint representing the column at the specified index, or -1 if the table does not implement this method.
        @rtype: int
        """
        return object
    
    def get_column_description(self, column=None):
        """        Gets the description text of the specified @column in the table
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gchar* representing the column description, or %NULL if value does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_column_extent_at(self, row=None, column=None):
        """        Gets the number of columns occupied by the accessible object
        at the specified @row and @column in the @table.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gint representing the column extent at specified position, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_column_header(self, column=None):
        """        Gets the column header of a specified column in an accessible table.
        @param column: a #gint representing a column in the table
        @type column: int
        @returns: a AtkObject* representing the specified column header, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_index_at(self, row=None, column=None):
        """        Gets a #gint representing the index at the specified @row and
        @column.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a #gint representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_n_columns(self):
        """        Gets the number of columns in the table.
        @returns: a gint representing the number of columns, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_n_rows(self):
        """        Gets the number of rows in the table.
        @returns: a gint representing the number of rows, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_row_at_index(self, index_=None):
        """        Gets a #gint representing the row at the specified @index_.
        @param index_: a #gint representing an index in @table
        @type index_: int
        @returns: a gint representing the row at the specified index, or -1 if the table does not implement this method.
        @rtype: int
        """
        return object
    
    def get_row_description(self, row=None):
        """        Gets the description text of the specified row in the table
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gchar* representing the row description, or %NULL if value does not implement this interface.
        @rtype: str
        """
        return object
    
    def get_row_extent_at(self, row=None, column=None):
        """        Gets the number of rows occupied by the accessible object
        at a specified @row and @column in the @table.
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gint representing the row extent at specified position, or 0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_row_header(self, row=None):
        """        Gets the row header of a specified row in an accessible table.
        @param row: a #gint representing a row in the table
        @type row: int
        @returns: a AtkObject* representing the specified row header, or %NULL if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def get_selected_columns(self, selected=None):
        """        Gets the selected columns of the table by initializing **selected with
        the selected column numbers. This array should be freed by the caller.
        @param selected: a #gint** that is to contain the selected columns numbers
        @type selected: int
        @returns: a gint representing the number of selected columns, or %0 if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_selected_rows(self, selected=None):
        """        Gets the selected rows of the table by initializing **selected with
        the selected row numbers. This array should be freed by the caller.
        @param selected: a #gint** that is to contain the selected row numbers
        @type selected: int
        @returns: a gint representing the number of selected rows, or zero if value does not implement this interface.
        @rtype: int
        """
        return object
    
    def get_summary(self):
        """        Gets the summary description of the table.
        @returns: a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.
        @rtype: Object
        """
        return object
    
    def is_column_selected(self, column=None):
        """        Gets a boolean value indicating whether the specified @column
        is selected
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def is_row_selected(self, row=None):
        """        Gets a boolean value indicating whether the specified @row
        is selected
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if the row is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def is_selected(self, row=None, column=None):
        """        Gets a boolean value indicating whether the accessible object
        at the specified @row and @column is selected
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: a gboolean representing if the cell is selected, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def ref_at(self, row=None, column=None):
        """        Get a reference to the table cell at @row, @column. This cell
        should implement the interface #AtkTableCell
        @param row: a #gint representing a row in @table
        @param column: a #gint representing a column in @table
        @type row: int
        @type column: int
        @returns: an #AtkObject representing the referred to accessible
        @rtype: Object
        """
        return object
    
    def remove_column_selection(self, column=None):
        """        Adds the specified @column to the selection.
        @param column: a #gint representing a column in @table
        @type column: int
        @returns: a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def remove_row_selection(self, row=None):
        """        Removes the specified @row from the selection.
        @param row: a #gint representing a row in @table
        @type row: int
        @returns: a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface.
        @rtype: bool
        """
        return object
    
    def set_caption(self, caption=None):
        """        Sets the caption for the table.
        @param caption: a #AtkObject representing the caption to set for @table
        @type caption: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_column_description(self, column=None, description=None):
        """        Sets the description text for the specified @column of the @table.
        @param column: a #gint representing a column in @table
        @param description: a #gchar representing the description text to set for the specified @column of the @table
        @type column: int
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_column_header(self, column=None, header=None):
        """        Sets the specified column header to @header.
        @param column: a #gint representing a column in @table
        @param header: an #AtkTable
        @type column: int
        @type header: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_row_description(self, row=None, description=None):
        """        Sets the description text for the specified @row of @table.
        @param row: a #gint representing a row in @table
        @param description: a #gchar representing the description text to set for the specified @row of @table
        @type row: int
        @type description: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_row_header(self, row=None, header=None):
        """        Sets the specified row header to @header.
        @param row: a #gint representing a row in @table
        @param header: an #AtkTable
        @type row: int
        @type header: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_summary(self, accessible=None):
        """        Sets the summary description of the table.
        @param accessible: an #AtkObject representing the summary description to set for @table
        @type accessible: Object
        @returns: 
        @rtype: None
        """
        return object


class TableCell():
    """Being #AtkTable a component which present elements ordered via rows
and columns, an #AtkTableCell is the interface which each of those
elements, so "cells" should implement.

See also #AtkTable."""
    
    def get_column_header_cells(self):
        """        Returns the column headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_column_span(self):
        """        Returns the number of columns occupied by this cell accessible.
        @returns: a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_position(self, row=None, column=None):
        """        Retrieves the tabular position of this cell.
        @param row: the row of the given cell.
        @param column: the column of the given cell.
        @type row: int
        @type column: int
        @returns: TRUE if successful; FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_row_column_span(self, row=None, column=None, row_span=None, column_span=None):
        """        Gets the row and column indexes and span of this cell accessible.
        
        Note: If the object does not implement this function, then, by default, atk
        will implement this function by calling get_row_span and get_column_span
        on the object.
        @param row: the row index of the given cell.
        @param column: the column index of the given cell.
        @param row_span: the number of rows occupied by this cell.
        @param column_span: the number of columns occupied by this cell.
        @type row: int
        @type column: int
        @type row_span: int
        @type column_span: int
        @returns: TRUE if successful; FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_row_header_cells(self):
        """        Returns the row headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_row_span(self):
        """        Returns the number of rows occupied by this cell accessible.
        @returns: a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_table(self):
        """        Returns a reference to the accessible of the containing table.
        @returns: the atk object for the containing table.
        @rtype: Object
        """
        return object
    
    def get_column_header_cells(self):
        """        Returns the column headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_column_span(self):
        """        Returns the number of columns occupied by this cell accessible.
        @returns: a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_position(self, row=None, column=None):
        """        Retrieves the tabular position of this cell.
        @param row: the row of the given cell.
        @param column: the column of the given cell.
        @type row: int
        @type column: int
        @returns: TRUE if successful; FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_row_column_span(self, row=None, column=None, row_span=None, column_span=None):
        """        Gets the row and column indexes and span of this cell accessible.
        
        Note: If the object does not implement this function, then, by default, atk
        will implement this function by calling get_row_span and get_column_span
        on the object.
        @param row: the row index of the given cell.
        @param column: the column index of the given cell.
        @param row_span: the number of rows occupied by this cell.
        @param column_span: the number of columns occupied by this cell.
        @type row: int
        @type column: int
        @type row_span: int
        @type column_span: int
        @returns: TRUE if successful; FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_row_header_cells(self):
        """        Returns the row headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_row_span(self):
        """        Returns the number of rows occupied by this cell accessible.
        @returns: a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_table(self):
        """        Returns a reference to the accessible of the containing table.
        @returns: the atk object for the containing table.
        @rtype: Object
        """
        return object


class TableCellIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_column_span(self):
        return object

    @property
    def get_column_header_cells(self):
        return object

    @property
    def get_position(self):
        return object

    @property
    def get_row_span(self):
        return object

    @property
    def get_row_header_cells(self):
        return object

    @property
    def get_row_column_span(self):
        return object

    @property
    def get_table(self):
        return object


class TableIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def ref_at(self):
        return object

    @property
    def get_index_at(self):
        return object

    @property
    def get_column_at_index(self):
        return object

    @property
    def get_row_at_index(self):
        return object

    @property
    def get_n_columns(self):
        return object

    @property
    def get_n_rows(self):
        return object

    @property
    def get_column_extent_at(self):
        return object

    @property
    def get_row_extent_at(self):
        return object

    @property
    def get_caption(self):
        return object

    @property
    def get_column_description(self):
        return object

    @property
    def get_column_header(self):
        return object

    @property
    def get_row_description(self):
        return object

    @property
    def get_row_header(self):
        return object

    @property
    def get_summary(self):
        return object

    @property
    def set_caption(self):
        return object

    @property
    def set_column_description(self):
        return object

    @property
    def set_column_header(self):
        return object

    @property
    def set_row_description(self):
        return object

    @property
    def set_row_header(self):
        return object

    @property
    def set_summary(self):
        return object

    @property
    def get_selected_columns(self):
        return object

    @property
    def get_selected_rows(self):
        return object

    @property
    def is_column_selected(self):
        return object

    @property
    def is_row_selected(self):
        return object

    @property
    def is_selected(self):
        return object

    @property
    def add_row_selection(self):
        return object

    @property
    def remove_row_selection(self):
        return object

    @property
    def add_column_selection(self):
        return object

    @property
    def remove_column_selection(self):
        return object

    @property
    def row_inserted(self):
        return object

    @property
    def column_inserted(self):
        return object

    @property
    def row_deleted(self):
        return object

    @property
    def column_deleted(self):
        return object

    @property
    def row_reordered(self):
        return object

    @property
    def column_reordered(self):
        return object

    @property
    def model_changed(self):
        return object


class Text():
    """#AtkText should be implemented by #AtkObjects on behalf of widgets
that have text content which is either attributed or otherwise
non-trivial.  #AtkObjects whose text content is simple,
unattributed, and very brief may expose that content via
#atk_object_get_name instead; however if the text is editable,
multi-line, typically longer than three or four words, attributed,
selectable, or if the object already uses the 'name' ATK property
for other information, the #AtkText interface should be used to
expose the text content.  In the case of editable text content,
#AtkEditableText (a subtype of the #AtkText interface) should be
implemented instead.

 #AtkText provides not only traversal facilities and change
notification for text content, but also caret tracking and glyph
bounding box calculations.  Note that the text strings are exposed
as UTF-8, and are therefore potentially multi-byte, and
caret-to-byte offset mapping makes no assumptions about the
character length; also bounding box glyph-to-offset mapping may be
complex for languages which use ligatures."""
    @staticmethod
    def free_ranges(ranges=None):
        """        Frees the memory associated with an array of AtkTextRange. It is assumed
        that the array was returned by the function atk_text_get_bounded_ranges
        and is NULL terminated.
        @param ranges: A pointer to an array of #AtkTextRange which is   to be freed.
        @returns: 
        @rtype: None
        """
        return object
    
    def add_selection(self, start_offset=None, end_offset=None):
        """        Adds a selection bounded by the specified offsets.
        @param start_offset: the start position of the selected region
        @param end_offset: the offset of the first character after the selected region.
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def get_bounded_ranges(self, rect=None, coord_type=None, x_clip_type=None, y_clip_type=None):
        """        
        @type rect: TextRectangle
        @type coord_type: CoordType
        @type x_clip_type: TextClipType
        @type y_clip_type: TextClipType
        @returns: 
        @rtype: TextRange
        """
        return object
    
    def get_caret_offset(self):
        """        Gets the offset position of the caret (cursor).
        @returns: the offset position of the caret (cursor).
        @rtype: int
        """
        return object
    
    def get_character_at_offset(self, offset=None):
        """        Gets the specified text.
        @param offset: position
        @type offset: int
        @returns: the character at @offset.
        @rtype: gunichar
        """
        return object
    
    def get_character_count(self):
        """        Gets the character count.
        @returns: the number of characters.
        @rtype: int
        """
        return object
    
    def get_character_extents(self, offset=None, x=None, y=None, width=None, height=None, coords=None):
        """        Get the bounding box containing the glyph representing the character at
            a particular text offset.
        @param offset: The offset of the text character for which bounding information is required.
        @param x: Pointer for the x cordinate of the bounding box
        @param y: Pointer for the y cordinate of the bounding box
        @param width: Pointer for the width of the bounding box
        @param height: Pointer for the height of the bounding box
        @param coords: specify whether coordinates are relative to the screen or widget window
        @type offset: int
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coords: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_default_attributes(self):
        """        Creates an #AtkAttributeSet which consists of the default values of
        attributes for the text. See the enum AtkTextAttribute for types of text
        attributes that can be returned. Note that other attributes may also be
        returned.
        @returns: an #AtkAttributeSet which contains the default values of attributes.  at @offset. this #atkattributeset should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_n_selections(self):
        """        Gets the number of selected regions.
        @returns: The number of selected regions, or -1 if a failure
   occurred.
        @rtype: int
        """
        return object
    
    def get_offset_at_point(self, x=None, y=None, coords=None):
        """        Gets the offset of the character located at coordinates @x and @y. @x and @y
        are interpreted as being relative to the screen or this widget's window
        depending on @coords.
        @param x: screen x-position of character
        @param y: screen y-position of character
        @param coords: specify whether coordinates are relative to the screen or widget window
        @type x: int
        @type y: int
        @type coords: CoordType
        @returns: the offset to the character which is located at the specified @x and @y coordinates.
        @rtype: int
        """
        return object
    
    def get_range_extents(self, start_offset=None, end_offset=None, coord_type=None, rect=None):
        """        Get the bounding box for text within the specified range.
        @param start_offset: The offset of the first text character for which boundary        information is required.
        @param end_offset: The offset of the text character after the last character        for which boundary information is required.
        @param coord_type: Specify whether coordinates are relative to the screen or widget window.
        @param rect: A pointer to a AtkTextRectangle which is filled in by this function.
        @type start_offset: int
        @type end_offset: int
        @type coord_type: CoordType
        @type rect: TextRectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_run_attributes(self, offset=None, start_offset=None, end_offset=None):
        """        Creates an #AtkAttributeSet which consists of the attributes explicitly
        set at the position @offset in the text. @start_offset and @end_offset are
        set to the start and end of the range around @offset where the attributes are
        invariant. Note that @end_offset is the offset of the first character
        after the range.  See the enum AtkTextAttribute for types of text
        attributes that can be returned. Note that other attributes may also be
        returned.
        @param offset: the offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
        @param start_offset: the address to put the start offset of the range
        @param end_offset: the address to put the end offset of the range
        @type offset: int
        @type start_offset: int
        @type end_offset: int
        @returns: an #AtkAttributeSet which contains the attributes explicitly set at @offset. This #AtkAttributeSet should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_selection(self, selection_num=None, start_offset=None, end_offset=None):
        """        Gets the text from the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @param start_offset: passes back the start position of the selected region
        @param end_offset: passes back the end position of (e.g. offset immediately past) the selected region
        @type selection_num: int
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the selected text. Use g_free()
   to free the returned string.
        @rtype: str
        """
        return object
    
    def get_string_at_offset(self, offset=None, granularity=None, start_offset=None, end_offset=None):
        """        Gets a portion of the text exposed through an #AtkText according to a given @offset
        and a specific @granularity, along with the start and end offsets defining the
        boundaries of such a portion of text.
        
        If @granularity is ATK_TEXT_GRANULARITY_CHAR the character at the
        offset is returned.
        
        If @granularity is ATK_TEXT_GRANULARITY_WORD the returned string
        is from the word start at or before the offset to the word start after
        the offset.
        
        The returned string will contain the word at the offset if the offset
        is inside a word and will contain the word before the offset if the
        offset is not inside a word.
        
        If @granularity is ATK_TEXT_GRANULARITY_SENTENCE the returned string
        is from the sentence start at or before the offset to the sentence
        start after the offset.
        
        The returned string will contain the sentence at the offset if the offset
        is inside a sentence and will contain the sentence before the offset
        if the offset is not inside a sentence.
        
        If @granularity is ATK_TEXT_GRANULARITY_LINE the returned string
        is from the line start at or before the offset to the line
        start after the offset.
        
        If @granularity is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
        is from the start of the paragraph at or before the offset to the start
        of the following paragraph after the offset.
        @param offset: position
        @param granularity: An #AtkTextGranularity
        @param start_offset: the start offset of the returned string, or -1                if an error has occurred (e.g. invalid offset, not implemented)
        @param end_offset: the offset of the first character after the returned string,              or -1 if an error has occurred (e.g. invalid offset, not implemented)
        @type offset: int
        @type granularity: TextGranularity
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text
   at the @offset bounded by the specified @granularity. Use
   g_free() to free the returned string.  Returns %NULL if the
   offset is invalid or no implementation is available.
        @rtype: str
        """
        return object
    
    def get_text(self, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param start_offset: start position
        @param end_offset: end position, or -1 for the end of the string.
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text from @start_offset up
   to, but not including @end_offset. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_after_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text after @offset bounded
   by the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_at_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        
        If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
        offset is returned.
        
        If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
        is from the word start at or before the offset to the word start after
        the offset.
        
        The returned string will contain the word at the offset if the offset
        is inside a word and will contain the word before the offset if the
        offset is not inside a word.
        
        If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
        string is from the sentence start at or before the offset to the sentence
        start after the offset.
        
        The returned string will contain the sentence at the offset if the offset
        is inside a sentence and will contain the sentence before the offset
        if the offset is not inside a sentence.
        
        If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
        string is from the line start at or before the offset to the line
        start after the offset.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text at @offset bounded by
   the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_before_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text before @offset bounded
   by the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def remove_selection(self, selection_num=None):
        """        Removes the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @type selection_num: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def set_caret_offset(self, offset=None):
        """        Sets the caret (cursor) position to the specified @offset.
        @param offset: position
        @type offset: int
        @returns: %TRUE if success, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_selection(self, selection_num=None, start_offset=None, end_offset=None):
        """        Changes the start and end offset of the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @param start_offset: the new start position of the selection
        @param end_offset: the new end position of (e.g. offset immediately past) the selection
        @type selection_num: int
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def text_attributes_changed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def text_caret_moved(self, location=None):
        """        
        @type location: int
        @returns: 
        @rtype: None
        """
        return object
    
    def text_changed(self, position=None, length=None):
        """        
        @type position: int
        @type length: int
        @returns: 
        @rtype: None
        """
        return object
    
    def text_selection_changed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def add_selection(self, start_offset=None, end_offset=None):
        """        Adds a selection bounded by the specified offsets.
        @param start_offset: the start position of the selected region
        @param end_offset: the offset of the first character after the selected region.
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def get_bounded_ranges(self, rect=None, coord_type=None, x_clip_type=None, y_clip_type=None):
        """        Get the ranges of text in the specified bounding box.
        @param rect: An AtkTextRectangle giving the dimensions of the bounding box.
        @param coord_type: Specify whether coordinates are relative to the screen or widget window.
        @param x_clip_type: Specify the horizontal clip type.
        @param y_clip_type: Specify the vertical clip type.
        @type rect: TextRectangle
        @type coord_type: CoordType
        @type x_clip_type: TextClipType
        @type y_clip_type: TextClipType
        @rtype: None
        """
        return object
    
    def get_caret_offset(self):
        """        Gets the offset position of the caret (cursor).
        @returns: the offset position of the caret (cursor).
        @rtype: int
        """
        return object
    
    def get_character_at_offset(self, offset=None):
        """        Gets the specified text.
        @param offset: position
        @type offset: int
        @returns: the character at @offset.
        @rtype: gunichar
        """
        return object
    
    def get_character_count(self):
        """        Gets the character count.
        @returns: the number of characters.
        @rtype: int
        """
        return object
    
    def get_character_extents(self, offset=None, x=None, y=None, width=None, height=None, coords=None):
        """        Get the bounding box containing the glyph representing the character at
            a particular text offset.
        @param offset: The offset of the text character for which bounding information is required.
        @param x: Pointer for the x cordinate of the bounding box
        @param y: Pointer for the y cordinate of the bounding box
        @param width: Pointer for the width of the bounding box
        @param height: Pointer for the height of the bounding box
        @param coords: specify whether coordinates are relative to the screen or widget window
        @type offset: int
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type coords: CoordType
        @returns: 
        @rtype: None
        """
        return object
    
    def get_default_attributes(self):
        """        Creates an #AtkAttributeSet which consists of the default values of
        attributes for the text. See the enum AtkTextAttribute for types of text
        attributes that can be returned. Note that other attributes may also be
        returned.
        @returns: an #AtkAttributeSet which contains the default values of attributes.  at @offset. this #atkattributeset should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_n_selections(self):
        """        Gets the number of selected regions.
        @returns: The number of selected regions, or -1 if a failure
   occurred.
        @rtype: int
        """
        return object
    
    def get_offset_at_point(self, x=None, y=None, coords=None):
        """        Gets the offset of the character located at coordinates @x and @y. @x and @y
        are interpreted as being relative to the screen or this widget's window
        depending on @coords.
        @param x: screen x-position of character
        @param y: screen y-position of character
        @param coords: specify whether coordinates are relative to the screen or widget window
        @type x: int
        @type y: int
        @type coords: CoordType
        @returns: the offset to the character which is located at the specified @x and @y coordinates.
        @rtype: int
        """
        return object
    
    def get_range_extents(self, start_offset=None, end_offset=None, coord_type=None, rect=None):
        """        Get the bounding box for text within the specified range.
        @param start_offset: The offset of the first text character for which boundary        information is required.
        @param end_offset: The offset of the text character after the last character        for which boundary information is required.
        @param coord_type: Specify whether coordinates are relative to the screen or widget window.
        @param rect: A pointer to a AtkTextRectangle which is filled in by this function.
        @type start_offset: int
        @type end_offset: int
        @type coord_type: CoordType
        @type rect: TextRectangle
        @returns: 
        @rtype: None
        """
        return object
    
    def get_run_attributes(self, offset=None, start_offset=None, end_offset=None):
        """        Creates an #AtkAttributeSet which consists of the attributes explicitly
        set at the position @offset in the text. @start_offset and @end_offset are
        set to the start and end of the range around @offset where the attributes are
        invariant. Note that @end_offset is the offset of the first character
        after the range.  See the enum AtkTextAttribute for types of text
        attributes that can be returned. Note that other attributes may also be
        returned.
        @param offset: the offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
        @param start_offset: the address to put the start offset of the range
        @param end_offset: the address to put the end offset of the range
        @type offset: int
        @type start_offset: int
        @type end_offset: int
        @returns: an #AtkAttributeSet which contains the attributes explicitly set at @offset. This #AtkAttributeSet should be freed by a call to atk_attribute_set_free().
        @rtype: AttributeSet
        """
        return object
    
    def get_selection(self, selection_num=None, start_offset=None, end_offset=None):
        """        Gets the text from the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @param start_offset: passes back the start position of the selected region
        @param end_offset: passes back the end position of (e.g. offset immediately past) the selected region
        @type selection_num: int
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the selected text. Use g_free()
   to free the returned string.
        @rtype: str
        """
        return object
    
    def get_string_at_offset(self, offset=None, granularity=None, start_offset=None, end_offset=None):
        """        Gets a portion of the text exposed through an #AtkText according to a given @offset
        and a specific @granularity, along with the start and end offsets defining the
        boundaries of such a portion of text.
        
        If @granularity is ATK_TEXT_GRANULARITY_CHAR the character at the
        offset is returned.
        
        If @granularity is ATK_TEXT_GRANULARITY_WORD the returned string
        is from the word start at or before the offset to the word start after
        the offset.
        
        The returned string will contain the word at the offset if the offset
        is inside a word and will contain the word before the offset if the
        offset is not inside a word.
        
        If @granularity is ATK_TEXT_GRANULARITY_SENTENCE the returned string
        is from the sentence start at or before the offset to the sentence
        start after the offset.
        
        The returned string will contain the sentence at the offset if the offset
        is inside a sentence and will contain the sentence before the offset
        if the offset is not inside a sentence.
        
        If @granularity is ATK_TEXT_GRANULARITY_LINE the returned string
        is from the line start at or before the offset to the line
        start after the offset.
        
        If @granularity is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
        is from the start of the paragraph at or before the offset to the start
        of the following paragraph after the offset.
        @param offset: position
        @param granularity: An #AtkTextGranularity
        @param start_offset: the start offset of the returned string, or -1                if an error has occurred (e.g. invalid offset, not implemented)
        @param end_offset: the offset of the first character after the returned string,              or -1 if an error has occurred (e.g. invalid offset, not implemented)
        @type offset: int
        @type granularity: TextGranularity
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text
   at the @offset bounded by the specified @granularity. Use
   g_free() to free the returned string.  Returns %NULL if the
   offset is invalid or no implementation is available.
        @rtype: str
        """
        return object
    
    def get_text(self, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param start_offset: start position
        @param end_offset: end position, or -1 for the end of the string.
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text from @start_offset up
   to, but not including @end_offset. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_after_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text after @offset bounded
   by the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_at_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        
        If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
        offset is returned.
        
        If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
        is from the word start at or before the offset to the word start after
        the offset.
        
        The returned string will contain the word at the offset if the offset
        is inside a word and will contain the word before the offset if the
        offset is not inside a word.
        
        If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
        string is from the sentence start at or before the offset to the sentence
        start after the offset.
        
        The returned string will contain the sentence at the offset if the offset
        is inside a sentence and will contain the sentence before the offset
        if the offset is not inside a sentence.
        
        If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
        string is from the line start at or before the offset to the line
        start after the offset.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text at @offset bounded by
   the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def get_text_before_offset(self, offset=None, boundary_type=None, start_offset=None, end_offset=None):
        """        Gets the specified text.
        @param offset: position
        @param boundary_type: An #AtkTextBoundary
        @param start_offset: the start offset of the returned string
        @param end_offset: the offset of the first character after the              returned substring
        @type offset: int
        @type boundary_type: TextBoundary
        @type start_offset: int
        @type end_offset: int
        @returns: a newly allocated string containing the text before @offset bounded
   by the specified @boundary_type. Use g_free() to free the returned string.
        @rtype: str
        """
        return object
    
    def remove_selection(self, selection_num=None):
        """        Removes the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @type selection_num: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def set_caret_offset(self, offset=None):
        """        Sets the caret (cursor) position to the specified @offset.
        @param offset: position
        @type offset: int
        @returns: %TRUE if success, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_selection(self, selection_num=None, start_offset=None, end_offset=None):
        """        Changes the start and end offset of the specified selection.
        @param selection_num: The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
        @param start_offset: the new start position of the selection
        @param end_offset: the new end position of (e.g. offset immediately past) the selection
        @type selection_num: int
        @type start_offset: int
        @type end_offset: int
        @returns: %TRUE if success, %FALSE otherwise
        @rtype: bool
        """
        return object


class TextIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_text(self):
        return object

    @property
    def get_text_after_offset(self):
        return object

    @property
    def get_text_at_offset(self):
        return object

    @property
    def get_character_at_offset(self):
        return object

    @property
    def get_text_before_offset(self):
        return object

    @property
    def get_caret_offset(self):
        return object

    @property
    def get_run_attributes(self):
        return object

    @property
    def get_default_attributes(self):
        return object

    @property
    def get_character_extents(self):
        return object

    @property
    def get_character_count(self):
        return object

    @property
    def get_offset_at_point(self):
        return object

    @property
    def get_n_selections(self):
        return object

    @property
    def get_selection(self):
        return object

    @property
    def add_selection(self):
        return object

    @property
    def remove_selection(self):
        return object

    @property
    def set_selection(self):
        return object

    @property
    def set_caret_offset(self):
        return object

    @property
    def text_changed(self):
        return object

    @property
    def text_caret_moved(self):
        return object

    @property
    def text_selection_changed(self):
        return object

    @property
    def text_attributes_changed(self):
        return object

    @property
    def get_range_extents(self):
        return object

    @property
    def get_bounded_ranges(self):
        return object

    @property
    def get_string_at_offset(self):
        return object


class TextRange():
    """A structure used to describe a text range."""

    @property
    def bounds(self):
        return object

    @property
    def start_offset(self):
        return object

    @property
    def end_offset(self):
        return object

    @property
    def content(self):
        return object


class TextRectangle():
    """A structure used to store a rectangle used by AtkText."""

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object


class Util(GObject.Object):
    """A set of ATK utility functions which are used to support event
registration of various types, and obtaining the 'root' accessible
of a process and information about the current ATK implementation
and toolkit version."""

    @property
    def parent(self):
        return object


class UtilClass():
    """"""

    @property
    def parent(self):
        return object

    @property
    def add_global_event_listener(self):
        return object

    @property
    def remove_global_event_listener(self):
        return object

    @property
    def add_key_event_listener(self):
        return object

    @property
    def remove_key_event_listener(self):
        return object

    @property
    def get_root(self):
        return object

    @property
    def get_toolkit_name(self):
        return object

    @property
    def get_toolkit_version(self):
        return object


class Value():
    """#AtkValue should be implemented for components which either display
a value from a bounded range, or which allow the user to specify a
value from a bounded range, or both. For instance, most sliders and
range controls, as well as dials, should have #AtkObject
representations which implement #AtkValue on the component's
behalf. #AtKValues may be read-only, in which case attempts to
alter the value return would fail.

<refsect1 id="current-value-text">
<title>On the subject of current value text</title>
<para>
In addition to providing the current value, implementors can
optionally provide an end-user-consumable textual description
associated with this value. This description should be included
when the numeric value fails to convey the full, on-screen
representation seen by users.
</para>

<example>
<title>Password strength</title>
A password strength meter whose value changes as the user types
their new password. Red is used for values less than 4.0, yellow
for values between 4.0 and 7.0, and green for values greater than
7.0. In this instance, value text should be provided by the
implementor. Appropriate value text would be "weak", "acceptable,"
and "strong" respectively.
</example>

A level bar whose value changes to reflect the battery charge. The
color remains the same regardless of the charge and there is no
on-screen text reflecting the fullness of the battery. In this
case, because the position within the bar is the only indication
the user has of the current charge, value text should not be
provided by the implementor.

<refsect2 id="implementor-notes">
<title>Implementor Notes</title>
<para>
Implementors should bear in mind that assistive technologies will
likely prefer the value text provided over the numeric value when
presenting a widget's value. As a result, strings not intended for
end users should not be exposed in the value text, and strings
which are exposed should be localized. In the case of widgets which
display value text on screen, for instance through a separate label
in close proximity to the value-displaying widget, it is still
expected that implementors will expose the value text using the
above API.
</para>

<para>
#AtkValue should NOT be implemented for widgets whose displayed
value is not reflective of a meaningful amount. For instance, a
progress pulse indicator whose value alternates between 0.0 and 1.0
to indicate that some process is still taking place should not
implement #AtkValue because the current value does not reflect
progress towards completion.
</para>
</refsect2>
</refsect1>

<refsect1 id="ranges">
<title>On the subject of ranges</title>
<para>
In addition to providing the minimum and maximum values,
implementors can optionally provide details about subranges
associated with the widget. These details should be provided by the
implementor when both of the following are communicated visually to
the end user:
</para>
<itemizedlist>
  <listitem>The existence of distinct ranges such as "weak",
  "acceptable", and "strong" indicated by color, bar tick marks,
  and/or on-screen text.</listitem>
  <listitem>Where the current value stands within a given subrange,
  for instance illustrating progression from very "weak" towards
  nearly "acceptable" through changes in shade and/or position on
  the bar within the "weak" subrange.</listitem>
</itemizedlist>
<para>
If both of the above do not apply to the widget, it should be
sufficient to expose the numeric value, along with the value text
if appropriate, to make the widget accessible.
</para>

<refsect2 id="ranges-implementor-notes">
<title>Implementor Notes</title>
<para>
If providing subrange details is deemed necessary, all possible
values of the widget are expected to fall within one of the
subranges defined by the implementor.
</para>
</refsect2>
</refsect1>

<refsect1 id="localization">
<title>On the subject of localization of end-user-consumable text
values</title>
<para>
Because value text and subrange descriptors are human-consumable,
implementors are expected to provide localized strings which can be
directly presented to end users via their assistive technology. In
order to simplify this for implementors, implementors can use
atk_value_type_get_localized_name() with the following
already-localized constants for commonly-needed values can be used:
</para>

<itemizedlist>
  <listitem>ATK_VALUE_VERY_WEAK</listitem>
  <listitem>ATK_VALUE_WEAK</listitem>
  <listitem>ATK_VALUE_ACCEPTABLE</listitem>
  <listitem>ATK_VALUE_STRONG</listitem>
  <listitem>ATK_VALUE_VERY_STRONG</listitem>
  <listitem>ATK_VALUE_VERY_LOW</listitem>
  <listitem>ATK_VALUE_LOW</listitem>
  <listitem>ATK_VALUE_MEDIUM</listitem>
  <listitem>ATK_VALUE_HIGH</listitem>
  <listitem>ATK_VALUE_VERY_HIGH</listitem>
  <listitem>ATK_VALUE_VERY_BAD</listitem>
  <listitem>ATK_VALUE_BAD</listitem>
  <listitem>ATK_VALUE_GOOD</listitem>
  <listitem>ATK_VALUE_VERY_GOOD</listitem>
  <listitem>ATK_VALUE_BEST</listitem>
  <listitem>ATK_VALUE_SUBSUBOPTIMAL</listitem>
  <listitem>ATK_VALUE_SUBOPTIMAL</listitem>
  <listitem>ATK_VALUE_OPTIMAL</listitem>
</itemizedlist>
<para>
Proposals for additional constants, along with their use cases,
should be submitted to the GNOME Accessibility Team.
</para>
</refsect1>

<refsect1 id="changes">
<title>On the subject of changes</title>
<para>
Note that if there is a textual description associated with the new
numeric value, that description should be included regardless of
whether or not it has also changed.
</para>
</refsect1>"""
    
    def get_current_value(self, value=None):
        """        Gets the value of this object.
        @param value: a #GValue representing the current accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_increment(self):
        """        Gets the minimum increment by which the value of this object may be
        changed.  If zero, the minimum increment is undefined, which may
        mean that it is limited only by the floating point precision of the
        platform.
        @returns: the minimum increment by which the value of this object may be changed. zero if undefined.
        @rtype: float
        """
        return object
    
    def get_maximum_value(self, value=None):
        """        Gets the maximum value of this object.
        @param value: a #GValue representing the maximum accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_minimum_increment(self, value=None):
        """        Gets the minimum increment by which the value of this object may be changed.  If zero,
        the minimum increment is undefined, which may mean that it is limited only by the
        floating point precision of the platform.
        @param value: a #GValue representing the minimum increment by which the accessible value may be changed
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_minimum_value(self, value=None):
        """        Gets the minimum value of this object.
        @param value: a #GValue representing the minimum accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_range(self):
        """        Gets the range of this object.
        @returns: a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
        @rtype: Range
        """
        return object
    
    def get_sub_ranges(self):
        """        Gets the list of subranges defined for this object. See #AtkValue
        introduction for examples of subranges and when to expose them.
        @returns: an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
        @rtype: GLib.SList
        """
        return object
    
    def get_value_and_text(self, value=None, text=None):
        """        Gets the current value and the human readable text alternative of
        @obj. @text is a newly created string, that must be freed by the
        caller. Can be NULL if no descriptor is available.
        @param value: address of #gdouble to put the current value of @obj
        @param text: address of #gchar to put the human readable text alternative for @value
        @type value: float
        @type text: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_current_value(self, value=None):
        """        Sets the value of this object.
        @param value: a #GValue which is the desired new accessible value.
        @type value: GObject.Value
        @returns: %TRUE if new value is successfully set, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_value(self, new_value=None):
        """        Sets the value of this object.
        
        This method is intended to provide a way to change the value of the
        object. In any case, it is possible that the value can't be
        modified (ie: a read-only component). If the value changes due this
        call, it is possible that the text could change, and will trigger
        an #AtkValue::value-changed signal emission.
        
        Note for implementors: the deprecated atk_value_set_current_value()
        method returned TRUE or FALSE depending if the value was assigned
        or not. In the practice several implementors were not able to
        decide it, and returned TRUE in any case. For that reason it is not
        required anymore to return if the value was properly assigned or
        not.
        @param new_value: a double which is the desired new accessible value.
        @type new_value: float
        @returns: 
        @rtype: None
        """
        return object
    
    def get_current_value(self, value=None):
        """        Gets the value of this object.
        @param value: a #GValue representing the current accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_increment(self):
        """        Gets the minimum increment by which the value of this object may be
        changed.  If zero, the minimum increment is undefined, which may
        mean that it is limited only by the floating point precision of the
        platform.
        @returns: the minimum increment by which the value of this object may be changed. zero if undefined.
        @rtype: float
        """
        return object
    
    def get_maximum_value(self, value=None):
        """        Gets the maximum value of this object.
        @param value: a #GValue representing the maximum accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_minimum_increment(self, value=None):
        """        Gets the minimum increment by which the value of this object may be changed.  If zero,
        the minimum increment is undefined, which may mean that it is limited only by the
        floating point precision of the platform.
        @param value: a #GValue representing the minimum increment by which the accessible value may be changed
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_minimum_value(self, value=None):
        """        Gets the minimum value of this object.
        @param value: a #GValue representing the minimum accessible value
        @type value: GObject.Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_range(self):
        """        Gets the range of this object.
        @returns: a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
        @rtype: Range
        """
        return object
    
    def get_sub_ranges(self):
        """        Gets the list of subranges defined for this object. See #AtkValue
        introduction for examples of subranges and when to expose them.
        @returns: an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
        @rtype: GLib.SList
        """
        return object
    
    def get_value_and_text(self, value=None, text=None):
        """        Gets the current value and the human readable text alternative of
        @obj. @text is a newly created string, that must be freed by the
        caller. Can be NULL if no descriptor is available.
        @param value: address of #gdouble to put the current value of @obj
        @param text: address of #gchar to put the human readable text alternative for @value
        @type value: float
        @type text: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_current_value(self, value=None):
        """        Sets the value of this object.
        @param value: a #GValue which is the desired new accessible value.
        @type value: GObject.Value
        @returns: %TRUE if new value is successfully set, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_value(self, new_value=None):
        """        Sets the value of this object.
        
        This method is intended to provide a way to change the value of the
        object. In any case, it is possible that the value can't be
        modified (ie: a read-only component). If the value changes due this
        call, it is possible that the text could change, and will trigger
        an #AtkValue::value-changed signal emission.
        
        Note for implementors: the deprecated atk_value_set_current_value()
        method returned TRUE or FALSE depending if the value was assigned
        or not. In the practice several implementors were not able to
        decide it, and returned TRUE in any case. For that reason it is not
        required anymore to return if the value was properly assigned or
        not.
        @param new_value: a double which is the desired new accessible value.
        @type new_value: float
        @returns: 
        @rtype: None
        """
        return object


class ValueIface():
    """"""

    @property
    def parent(self):
        return object

    @property
    def get_current_value(self):
        return object

    @property
    def get_maximum_value(self):
        return object

    @property
    def get_minimum_value(self):
        return object

    @property
    def set_current_value(self):
        return object

    @property
    def get_minimum_increment(self):
        return object

    @property
    def get_value_and_text(self):
        return object

    @property
    def get_range(self):
        return object

    @property
    def get_increment(self):
        return object

    @property
    def get_sub_ranges(self):
        return object

    @property
    def set_value(self):
        return object


class Window():
    """#AtkWindow should be implemented by the UI elements that represent
a top-level window, such as the main window of an application or
dialog."""


class WindowIface():
    """"""

    @property
    def parent(self):
        return object


class GObjectAccessible(Object):
    """This object class is derived from AtkObject. It can be used as a
basis for implementing accessible objects for GObjects which are
not derived from GtkWidget. One example of its use is in providing
an accessible object for GnomeCanvasItem in the GAIL library."""
    @staticmethod
    def for_object(obj=None):
        """        Gets the accessible object for the specified @obj.
        @param obj: a #GObject
        @type obj: GObject.Object
        @returns: a #AtkObject which is the accessible object for the @obj
        @rtype: Object
        """
        return object
    
    def get_object(self):
        """        Gets the GObject for which @obj is the accessible object.
        @returns: a #GObject which is the object for which @obj is the accessible object
        @rtype: GObject.Object
        """
        return object

    @property
    def parent(self):
        return object


class NoOpObject(Object, Action, Component, Document, EditableText, Hypertext, Image, Selection, Table, TableCell, Text, Value, Window):
    """An AtkNoOpObject is an AtkObject which purports to implement all
ATK interfaces. It is the type of AtkObject which is created if an
accessible object is requested for an object type for which no
factory type is specified."""
    
    def __init__(self, obj=None):
        """        Provides a default (non-functioning stub) #AtkObject.
        Application maintainers should not use this method.
        @param obj: a #GObject
        @type obj: GObject.Object
        @returns: Newly created NoOpObject
        @rtype: NoOpObject
        """
        return object
    @staticmethod
    def new(obj=None):
        """        Provides a default (non-functioning stub) #AtkObject.
        Application maintainers should not use this method.
        @param obj: a #GObject
        @type obj: GObject.Object
        @returns: Newly created NoOpObject
        @rtype: NoOpObject
        """
        return object

    @property
    def parent(self):
        return object


class NoOpObjectFactory(ObjectFactory):
    """The AtkObjectFactory which creates an AtkNoOpObject. An instance of
this is created by an AtkRegistry if no factory type has not been
specified to create an accessible object of a particular type."""
    
    def __init__(self):
        """        Creates an instance of an #AtkObjectFactory which generates primitive
        (non-functioning) #AtkObjects.
        @returns: Newly created NoOpObjectFactory
        @rtype: NoOpObjectFactory
        """
        return object
    @staticmethod
    def new():
        """        Creates an instance of an #AtkObjectFactory which generates primitive
        (non-functioning) #AtkObjects.
        @returns: Newly created NoOpObjectFactory
        @rtype: NoOpObjectFactory
        """
        return object

    @property
    def parent(self):
        return object
